spLib
Loading...
Searching...
No Matches
<sp/window.h>: Window Functions

Blackman Window (<sp/window.h>)

void blackmanf (float *window, long length)
 
void blackman (double *window, long length)
 
void nblackmanf (float *window, long length)
 
void nblackman (double *window, long length)
 

Hamming Window (<sp/window.h>)

void hammingf (float *window, long length)
 
void hamming (double *window, long length)
 
void nhammingf (float *window, long length)
 
void nhamming (double *window, long length)
 

Hanning Window (<sp/window.h>)

void hanningf (float *window, long length)
 
void hanning (double *window, long length)
 
void nhanningf (float *window, long length)
 
void nhanning (double *window, long length)
 

Hann Window (<sp/window.h>)

void hannf (float *window, long length)
 
void hann (double *window, long length)
 
void nhannf (float *window, long length)
 
void nhann (double *window, long length)
 

Gaussian Window (<sp/window.h>)

void gausswinf (float *window, long length, float alpha)
 
void gausswin (double *window, long length, double alpha)
 
void ngausswinf (float *window, long length, float alpha)
 
void ngausswin (double *window, long length, double alpha)
 

Rectangular Window (<sp/window.h>)

void nboxcarf (float *window, long length)
 
void nboxcar (double *window, long length)
 

Blackman Window for Vector (<sp/window.h>)

void dvblackman (spDVector vec)
 
void dvnblackman (spDVector vec)
 
void fvblackman (spFVector vec)
 
spFVector xfvblackmanul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvblackmanul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvblackman (long length)
 
spDVector xdvblackman (long length)
 
void fvnblackman (spFVector vec)
 
spFVector xfvnblackmanul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvnblackmanul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvnblackman (long length)
 
spDVector xdvnblackman (long length)
 

Hamming Window for Vector (<sp/window.h>)

void dvhamming (spDVector vec)
 
void dvnhamming (spDVector vec)
 
void fvhamming (spFVector vec)
 
spFVector xfvhammingul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvhammingul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvhamming (long length)
 
spDVector xdvhamming (long length)
 
void fvnhamming (spFVector vec)
 
spFVector xfvnhammingul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvnhammingul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvnhamming (long length)
 
spDVector xdvnhamming (long length)
 

Hanning Window for Vector (<sp/window.h>)

void dvhanning (spDVector vec)
 
void dvnhanning (spDVector vec)
 
void fvhanning (spFVector vec)
 
spFVector xfvhanningul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvhanningul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvhanning (long length)
 
spDVector xdvhanning (long length)
 
void fvnhanning (spFVector vec)
 
spFVector xfvnhanningul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvnhanningul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvnhanning (long length)
 
spDVector xdvnhanning (long length)
 

Hann Window for Vector (<sp/window.h>)

void dvhann (spDVector vec)
 
void dvnhann (spDVector vec)
 
void fvhann (spFVector vec)
 
spFVector xfvhannul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvhannul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvhann (long length)
 
spDVector xdvhann (long length)
 
void fvnhann (spFVector vec)
 
spFVector xfvnhannul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvnhannul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvnhann (long length)
 
spDVector xdvnhann (long length)
 

Gaussian Window for Vector (<sp/window.h>)

void dvgausswinex (spDVector vec, double alpha)
 
void dvgausswin (spDVector vec)
 
void dvngausswinex (spDVector vec, double alpha)
 
void dvngausswin (spDVector vec)
 
void fvgausswinex (spFVector vec, float alpha)
 
spFVector xfvgausswinexul (spPlugin *plugin, long length, float alpha, spBool unlock_flag)
 
spDVector xdvgausswinexul (spPlugin *plugin, long length, double alpha, spBool unlock_flag)
 
spFVector xfvgausswinex (long length, float alpha)
 
spDVector xdvgausswinex (long length, double alpha)
 
void fvgausswin (spFVector vec)
 
spFVector xfvgausswinul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvgausswinul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvgausswin (long length)
 
spDVector xdvgausswin (long length)
 
void fvngausswinex (spFVector vec, float alpha)
 
spFVector xfvngausswinexul (spPlugin *plugin, long length, float alpha, spBool unlock_flag)
 
spDVector xdvngausswinexul (spPlugin *plugin, long length, double alpha, spBool unlock_flag)
 
spFVector xfvngausswinex (long length, float alpha)
 
spDVector xdvngausswinex (long length, double alpha)
 
void fvngausswin (spFVector vec)
 
spFVector xfvngausswinul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvngausswinul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvngausswin (long length)
 
spDVector xdvngausswin (long length)
 

Rectangular Window for Vector (<sp/window.h>)

void dvnboxcar (spDVector vec)
 
void fvnboxcar (spFVector vec)
 
spFVector xfvnboxcarul (spPlugin *plugin, long length, spBool unlock_flag)
 
spDVector xdvnboxcarul (spPlugin *plugin, long length, spBool unlock_flag)
 
spFVector xfvnboxcar (long length)
 
spDVector xdvnboxcar (long length)
 

Detailed Description

#include <sp/window.h>

Function Documentation

◆ blackmanf()

void blackmanf ( float * window,
long length )
extern

Create a Blackman window of length for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ blackman()

void blackman ( double * window,
long length )
extern

Create a Blackman window of length for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ nblackmanf()

void nblackmanf ( float * window,
long length )
extern

Create a Blackman window of length normalized by the RMS for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ nblackman()

void nblackman ( double * window,
long length )
extern

Create a Blackman window of length normalized by the RMS for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ hammingf()

void hammingf ( float * window,
long length )
extern

Create a Hamming window of length for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ hamming()

void hamming ( double * window,
long length )
extern

Create a Hamming window of length for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ nhammingf()

void nhammingf ( float * window,
long length )
extern

Create a Hamming window of length normalized by the RMS for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ nhamming()

void nhamming ( double * window,
long length )
extern

Create a Hamming window of length normalized by the RMS for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ hanningf()

void hanningf ( float * window,
long length )
extern

Create a Hanning window of length for the output buffer window . The generated window doesn't include left and right edges with 0 in contrast to hann() or hannf() . The output buffer window must be an array or a memory-allocated buffer.

◆ hanning()

void hanning ( double * window,
long length )
extern

Create a Hanning window of length for the output buffer window . The generated window doesn't include left and right edges with 0 in contrast to hann() or hannf() . The output buffer window must be an array or a memory-allocated buffer.

◆ nhanningf()

void nhanningf ( float * window,
long length )
extern

Create a Hanning window of length normalized by the RMS for the output buffer window . The generated window doesn't include left and right edges with 0 in contrast to nhann() or nhannf() . The output buffer window must be an array or a memory-allocated buffer.

◆ nhanning()

void nhanning ( double * window,
long length )
extern

Create a Hanning window of length normalized by the RMS for the output buffer window . The generated window doesn't include left and right edges with 0 in contrast to nhann() or nhannf() . The output buffer window must be an array or a memory-allocated buffer.

◆ hannf()

void hannf ( float * window,
long length )
extern

Create a Hann window of length for the output buffer window . The generated window includes left and right edges with 0 in contrast to hanning() or hanningf() . The output buffer window must be an array or a memory-allocated buffer.

◆ hann()

void hann ( double * window,
long length )
extern

Create a Hann window of length for the output buffer window . The generated window includes left and right edges with 0 in contrast to hanning() or hanningf() . The output buffer window must be an array or a memory-allocated buffer.

◆ nhannf()

void nhannf ( float * window,
long length )
extern

Create a Hann window of length normalized by the RMS for the output buffer window . The generated window includes left and right edges with 0 in contrast to nhanning() or nhanningf() . The output buffer window must be an array or a memory-allocated buffer.

◆ nhann()

void nhann ( double * window,
long length )
extern

Create a Hann window of length normalized by the RMS for the output buffer window . The generated window includes left and right edges with 0 in contrast to nhanning() or nhanningf() . The output buffer window must be an array or a memory-allocated buffer.

◆ gausswinf()

void gausswinf ( float * window,
long length,
float alpha )
extern

Create a Gaussian window of length for the output buffer window . The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) . The output buffer window must be an array or a memory-allocated buffer.

◆ gausswin()

void gausswin ( double * window,
long length,
double alpha )
extern

Create a Gaussian window of length for the output buffer window . The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) . The output buffer window must be an array or a memory-allocated buffer.

◆ ngausswinf()

void ngausswinf ( float * window,
long length,
float alpha )
extern

Create a Gaussian window of length normalized by the RMS for the output buffer window . The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) . The output buffer window must be an array or a memory-allocated buffer.

◆ ngausswin()

void ngausswin ( double * window,
long length,
double alpha )
extern

Create a Gaussian window of length normalized by the RMS for the output buffer window . The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) . The output buffer window must be an array or a memory-allocated buffer.

◆ nboxcarf()

void nboxcarf ( float * window,
long length )
extern

Create a rectangular window of length normalized by the RMS for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ nboxcar()

void nboxcar ( double * window,
long length )
extern

Create a rectangular window of length normalized by the RMS for the output buffer window . The output buffer window must be an array or a memory-allocated buffer.

◆ dvblackman()

void dvblackman ( spDVector vec)
extern

Create a Blackman window for the vector vec . The vector vec must be a memory-allocated vector.

◆ dvnblackman()

void dvnblackman ( spDVector vec)
extern

Create a Blackman window normalized by the RMS for the vector vec . The vector vec must be a memory-allocated vector.

◆ dvhamming()

void dvhamming ( spDVector vec)
extern

Create a Hamming window for the vector vec . The vector vec must be a memory-allocated vector.

◆ dvnhamming()

void dvnhamming ( spDVector vec)
extern

Create a Hamming window normalized by the RMS for the vector vec . The vector vec must be a memory-allocated vector.

◆ dvhanning()

void dvhanning ( spDVector vec)
extern

Create a Hanning window for the vector vec . The generated window doesn't include left and right edges with 0 in contrast to dvhann() or fvhann() . The vector vec must be a memory-allocated vector.

◆ dvnhanning()

void dvnhanning ( spDVector vec)
extern

Create a Hanning window normalized by the RMS for the vector vec . The generated window doesn't include left and right edges with 0 in contrast to dvnhann() or fvnhann() . The vector vec must be a memory-allocated vector.

◆ dvhann()

void dvhann ( spDVector vec)
extern

Create a Hann window for the vector vec . The generated window includes left and right edges with 0 in contrast to dvhanning() or fvhanning() . The vector vec must be a memory-allocated vector.

◆ dvnhann()

void dvnhann ( spDVector vec)
extern

Create a Hann window normalized by the RMS for the vector vec . The generated window includes left and right edges with 0 in contrast to dvnhanning() or fvnhanning() . The vector vec must be a memory-allocated vector.

◆ dvgausswinex()

void dvgausswinex ( spDVector vec,
double alpha )
extern

Create a Gaussian window for the vector vec . The standard deviation of the Gaussian is determined by (vec->length - 1) / (2 * alpha) . The vector vec must be a memory-allocated vector.

◆ dvgausswin()

void dvgausswin ( spDVector vec)
extern

Create a Gaussian window for the vector vec . The standard deviation of the Gaussian is determined by (vec->length - 1) / 5 . The vector vec must be a memory-allocated vector.

◆ dvngausswinex()

void dvngausswinex ( spDVector vec,
double alpha )
extern

Create a Gaussian window normalized by the RMS for the vector vec . The standard deviation of the Gaussian is determined by (vec->length - 1) / (2 * alpha) . The vector vec must be a memory-allocated vector.

◆ dvngausswin()

void dvngausswin ( spDVector vec)
extern

Create a Gaussian window normalized by the RMS for the vector vec . The standard deviation of the Gaussian is determined by (vec->length - 1) / 5 . The vector vec must be a memory-allocated vector.

◆ dvnboxcar()

void dvnboxcar ( spDVector vec)
extern

Create a rectangular window normalized by the RMS for the vector vec . The vector vec must be a memory-allocated vector.

◆ fvblackman()

void fvblackman ( spFVector vec)

◆ xfvblackmanul()

spFVector xfvblackmanul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Blackman window of length .

◆ xdvblackmanul()

spDVector xdvblackmanul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Blackman window of length .

◆ xfvblackman()

spFVector xfvblackman ( long length)

Create a new vector whose contents are a Blackman window of length .

◆ xdvblackman()

spDVector xdvblackman ( long length)

Create a new vector whose contents are a Blackman window of length .

◆ fvnblackman()

void fvnblackman ( spFVector vec)

◆ xfvnblackmanul()

spFVector xfvnblackmanul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Blackman window of length normalized by the RMS.

◆ xdvnblackmanul()

spDVector xdvnblackmanul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Blackman window of length normalized by the RMS.

◆ xfvnblackman()

spFVector xfvnblackman ( long length)

Create a new vector whose contents are a Blackman window of length normalized by the RMS.

◆ xdvnblackman()

spDVector xdvnblackman ( long length)

Create a new vector whose contents are a Blackman window of length normalized by the RMS.

◆ fvhamming()

void fvhamming ( spFVector vec)

◆ xfvhammingul()

spFVector xfvhammingul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hamming window of length .

◆ xdvhammingul()

spDVector xdvhammingul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hamming window of length .

◆ xfvhamming()

spFVector xfvhamming ( long length)

Create a new vector whose contents are a Hamming window of length .

◆ xdvhamming()

spDVector xdvhamming ( long length)

Create a new vector whose contents are a Hamming window of length .

◆ fvnhamming()

void fvnhamming ( spFVector vec)

◆ xfvnhammingul()

spFVector xfvnhammingul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hamming window of length normalized by the RMS.

◆ xdvnhammingul()

spDVector xdvnhammingul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hamming window of length normalized by the RMS.

◆ xfvnhamming()

spFVector xfvnhamming ( long length)

Create a new vector whose contents are a Hamming window of length normalized by the RMS.

◆ xdvnhamming()

spDVector xdvnhamming ( long length)

Create a new vector whose contents are a Hamming window of length normalized by the RMS.

◆ fvhanning()

void fvhanning ( spFVector vec)

◆ xfvhanningul()

spFVector xfvhanningul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hanning window of length . The window doesn't include left and right edges with 0 in contrast to xdvhannul() or xfvhannul() .

◆ xdvhanningul()

spDVector xdvhanningul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hanning window of length . The window doesn't include left and right edges with 0 in contrast to xdvhannul() or xfvhannul() .

◆ xfvhanning()

spFVector xfvhanning ( long length)

Create a new vector whose contents are a Hanning window of length . The window doesn't include left and right edges with 0 in contrast to xdvhann() or xfvhann() .

◆ xdvhanning()

spDVector xdvhanning ( long length)

Create a new vector whose contents are a Hanning window of length . The window doesn't include left and right edges with 0 in contrast to xdvhann() or xfvhann() .

◆ fvnhanning()

void fvnhanning ( spFVector vec)

◆ xfvnhanningul()

spFVector xfvnhanningul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hanning window of length normalized by the RMS. The window doesn't include left and right edges with 0 in contrast to xdvnhannul() or xfvnhannul() .

◆ xdvnhanningul()

spDVector xdvnhanningul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hanning window of length normalized by the RMS. The window doesn't include left and right edges with 0 in contrast to xdvnhannul() or xfvnhannul() .

◆ xfvnhanning()

spFVector xfvnhanning ( long length)

Create a new vector whose contents are a Hanning window of length normalized by the RMS. The window doesn't include left and right edges with 0 in contrast to xdvnhann() or xfvnhann() .

◆ xdvnhanning()

spDVector xdvnhanning ( long length)

Create a new vector whose contents are a Hanning window of length normalized by the RMS. The window doesn't include left and right edges with 0 in contrast to xdvnhann() or xfvnhann() .

◆ fvhann()

void fvhann ( spFVector vec)

◆ xfvhannul()

spFVector xfvhannul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hann window of length . The window includes left and right edges with 0 in contrast to xdvhanningul() or xfvhanningul() .

◆ xdvhannul()

spDVector xdvhannul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hann window of length . The window includes left and right edges with 0 in contrast to xdvhanningul() or xfvhanningul() .

◆ xfvhann()

spFVector xfvhann ( long length)

Create a new vector whose contents are a Hann window of length . The window includes left and right edges with 0 in contrast to xdvhanning() or xfvhanning() .

◆ xdvhann()

spDVector xdvhann ( long length)

Create a new vector whose contents are a Hann window of length . The window includes left and right edges with 0 in contrast to xdvhanning() or xfvhanning() .

◆ fvnhann()

void fvnhann ( spFVector vec)

◆ xfvnhannul()

spFVector xfvnhannul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hann window of length normalized by the RMS. The window includes left and right edges with 0 in contrast to xdvnhanningul() or xfvnhanningul() .

◆ xdvnhannul()

spDVector xdvnhannul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Hann window of length normalized by the RMS. The window includes left and right edges with 0 in contrast to xdvnhanningul() or xfvnhanningul() .

◆ xfvnhann()

spFVector xfvnhann ( long length)

Create a new vector whose contents are a Hann window of length normalized by the RMS. The window includes left and right edges with 0 in contrast to xdvnhanning() or xfvnhanning() .

◆ xdvnhann()

spDVector xdvnhann ( long length)

Create a new vector whose contents are a Hann window of length normalized by the RMS. The window includes left and right edges with 0 in contrast to xdvnhanning() or xfvnhanning() .

◆ fvgausswinex()

void fvgausswinex ( spFVector vec,
float alpha )

◆ xfvgausswinexul()

spFVector xfvgausswinexul ( spPlugin * plugin,
long length,
float alpha,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Gaussian window of length . The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) .

◆ xdvgausswinexul()

spDVector xdvgausswinexul ( spPlugin * plugin,
long length,
double alpha,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Gaussian window of length . The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) .

◆ xfvgausswinex()

spFVector xfvgausswinex ( long length,
float alpha )

Create a new vector whose contents are a Gaussian window of length . The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) .

◆ xdvgausswinex()

spDVector xdvgausswinex ( long length,
double alpha )

Create a new vector whose contents are a Gaussian window of length . The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) .

◆ fvgausswin()

void fvgausswin ( spFVector vec)

◆ xfvgausswinul()

spFVector xfvgausswinul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Gaussian window of length . The standard deviation of the Gaussian is determined by (length - 1) / 5 .

◆ xdvgausswinul()

spDVector xdvgausswinul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Gaussian window of length . The standard deviation of the Gaussian is determined by (length - 1) / 5 .

◆ xfvgausswin()

spFVector xfvgausswin ( long length)

Create a new vector whose contents are a Gaussian window of length . The standard deviation of the Gaussian is determined by (length - 1) / 5 .

◆ xdvgausswin()

spDVector xdvgausswin ( long length)

Create a new vector whose contents are a Gaussian window of length . The standard deviation of the Gaussian is determined by (length - 1) / 5 .

◆ fvngausswinex()

void fvngausswinex ( spFVector vec,
float alpha )

◆ xfvngausswinexul()

spFVector xfvngausswinexul ( spPlugin * plugin,
long length,
float alpha,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Gaussian window of length normalized by the RMS. The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) .

◆ xdvngausswinexul()

spDVector xdvngausswinexul ( spPlugin * plugin,
long length,
double alpha,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Gaussian window of length normalized by the RMS. The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) .

◆ xfvngausswinex()

spFVector xfvngausswinex ( long length,
float alpha )

Create a new vector whose contents are a Gaussian window of length normalized by the RMS. The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) .

◆ xdvngausswinex()

spDVector xdvngausswinex ( long length,
double alpha )

Create a new vector whose contents are a Gaussian window of length normalized by the RMS. The standard deviation of the Gaussian is determined by (length - 1) / (2 * alpha) .

◆ fvngausswin()

void fvngausswin ( spFVector vec)

◆ xfvngausswinul()

spFVector xfvngausswinul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Gaussian window of length normalized by the RMS. The standard deviation of the Gaussian is determined by (length - 1) / 5 .

◆ xdvngausswinul()

spDVector xdvngausswinul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a Gaussian window of length normalized by the RMS. The standard deviation of the Gaussian is determined by (length - 1) / 5 .

◆ xfvngausswin()

spFVector xfvngausswin ( long length)

Create a new vector whose contents are a Gaussian window of length normalized by the RMS. The standard deviation of the Gaussian is determined by (length - 1) / 5 .

◆ xdvngausswin()

spDVector xdvngausswin ( long length)

Create a new vector whose contents are a Gaussian window of length normalized by the RMS. The standard deviation of the Gaussian is determined by (length - 1) / 5 .

◆ fvnboxcar()

void fvnboxcar ( spFVector vec)

◆ xfvnboxcarul()

spFVector xfvnboxcarul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a rectangular window of length normalized by the RMS.

◆ xdvnboxcarul()

spDVector xdvnboxcarul ( spPlugin * plugin,
long length,
spBool unlock_flag )

Create a new plugin-based vector whose contents are a rectangular window of length normalized by the RMS.

◆ xfvnboxcar()

spFVector xfvnboxcar ( long length)

Create a new vector whose contents are a rectangular window of length normalized by the RMS.

◆ xdvnboxcar()

spDVector xdvnboxcar ( long length)

Create a new vector whose contents are a rectangular window of length normalized by the RMS.

Generated by doxygen 1.11.0