RTF_CREATE_FILTER(3) rtfilter library RTF_CREATE_FILTER(3)NAME
rtf_create_filter - Creates a custom filter
SYNOPSIS
#include <rtfilter.h>
hfilter rtf_create_filter(unsigned int nchann, int proctype,
unsigned int num_len, const void *num,
unsigned int denum_len, const void *denum,
int type);
DESCRIPTION
This function creates and initializes a digital linear filter whose the Z-transform is rational and processing nchann channels of a data
type specified by proctype.
The numerator and denominator of the rational expression are specified by respectively two arrays num and denum containing the coefficients
in the ascending order of the 2 polynoms. The number of elements in each arrays is controlled by num_len and enum_len. denum_len is
allowed to be equal to zero as well as denum is allowed to be NULL. In such case, the denominator will be set to 1. The data type of the
values in num and denum are specified by type.
The proctype and type must be one the following constants:
RTF_FLOAT specifies real single precision (float)
RTF_DOUBLE specifies real double precision (double)
RTF_CFLOAT specifies complex single precision (complex float)
RTF_CDOUBLE specifies complex double precision (complex double)
The expected data type of the output of the filter has the same precision as the one specified by proctype and is complex proctype or type
specifies a complex type. Said otherwise:
* If proctype is RTF_FLOAT or RTF_CFLOAT then the output data type will have single precision. Otherwise it will have double precision.
* If proctype or type specifies a complex type, then the output will be complex as well. Otherwise, it will be real.
rtf_create_filter() can be used to use a filter that has been designed somewhere else. In particular, this function can be used directly
with the output of filter design function of MATLAB. In such case, the usual B and A arrays returned by the filter design functions corre-
sponds exactly to respectively num and denum.
RETURN VALUE
Returns the handle to the created filter in case of success, NULL otherwise.
PERFORMANCE CONSIDERATION
See note of rtf_filter(3)SEE ALSO rtf_destroy_filter(3), rtf_init_filter(3), rtf_filter(3)EPFL 2010 RTF_CREATE_FILTER(3)
Check Out this Related Man Page
vz_pow_(3MVEC) Vector Math Library Functions vz_pow_(3MVEC)NAME
vz_pow_, vc_pow_ - vector complex power functions
SYNOPSIS
cc [ flag... ] file... -lmvec [ library... ]
void vz_pow_(int *n, double complex * restrict z,
int *stridez, double complex * restrict w, int *stridew,
double complex * restrict u, int *strideu,
double * tmp);
void vc_pow_(int *n, float complex * restrict z,
int *stridez, float complex * restrict w, int *stridew,
float complex * restrict u, int *strideu,
float * tmp);
DESCRIPTION
These functions evaluate the complex function z^w for an entire vector of values at once. The first parameter specifies the number of val-
ues to compute. Subsequent parameters specify the argument and result vectors. Each vector is described by a pointer to the first element
and a stride, which is the increment between successive elements. The last argument is a pointer to scratch storage; this storage must be
large enough to hold 3 * *n consecutive values of the real type corresponding to the complex type of the argument and result.
Specifically, vz_pow_(n, z, sz, w, sw, u, su, tmp) computes u[i * *su] = (z[i * *sz])^(w[i * *sw]) for each i = 0, 1, ..., *n - 1. The
vc_pow_() function performs the same computation for single precision data.
These functions are not guaranteed to deliver results that are identical to the results of the cpow(3M) functions given the same arguments.
USAGE
The element count *n must be greater than zero. The strides for the argument and result arrays can be arbitrary integers, but the arrays
themselves must not be the same or overlap. A zero stride effectively collapses an entire vector into a single element. A negative stride
causes a vector to be accessed in descending memory order, but note that the corresponding pointer must still point to the first element of
the vector to be used; if the stride is negative, this will be the highest-addressed element in memory. This convention differs from the
Level 1 BLAS, in which array parameters always refer to the lowest-addressed element in memory even when negative increments are used.
These functions assume that the default round-to-nearest rounding direction mode is in effect. On x86, these functions also assume that the
default round-to-64-bit rounding precision mode is in effect. The result of calling a vector function with a non-default rounding mode in
effect is undefined.
Unlike the c99 cpow(3M) functions, the vector complex exponential functions make no attempt to handle special cases and exceptions; they
simply use textbook formulas to compute a complex exponential in terms of real elementary functions. As a result, these functions can raise
different exceptions and/or deliver different results from cpow().
ATTRIBUTES
See attributes(5) for descriptions of the following attributes:
+-----------------------------+-----------------------------+
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+-----------------------------+-----------------------------+
|Interface Stability |Committed |
+-----------------------------+-----------------------------+
|MT-Level |MT-Safe |
+-----------------------------+-----------------------------+
SEE ALSO cpow(3M), attributes(5)SunOS 5.11 14 Dec 2007 vz_pow_(3MVEC)