SYNOPSIS
#include "matrix.h" VEC *v_conv (VEC *x, VEC *y, VEC *out) VEC *v_pconv(VEC *x, VEC *y, VEC *out) VEC *v_map (double (*fn)(double), VEC *x, VEC *out) double v_max (VEC *x, int *index) double v_min (VEC *x, int *index) VEC *v_star (VEC *x, VEC *y, VEC *out) VEC *v_slash(VEC *x, VEC *y, VEC *out) VEC *v_sort (VEC *x, PERM *order) double v_sum (VEC *x)
#include "mzatrix.h" ZVEC *zv_map(complex (*fn)(complex), ZVEC *x, ZVEC *out) ZVEC *zv_star(ZVEC *x, ZVEC *y, ZVEC *out) ZVEC *zv_slash(ZVEC *x, ZVEC *y, ZVEC *out) complex zv_sum(ZVEC *x)
DESCRIPTION
The routines v_conv() and v_pconv() compute convolution-type products of vectors. The routine v_conv() computes the vector $z$ where $z_i = \sum_{0\le j\le i} x_j y_{i-j}$. The routine v_pconv() computes a periodic convolution with period y->dim. The routine v_conv() can be used to compute the product of two polynomials, with the polynomial $x(t) = \sum_{i=0}^{\deg x} x_i t^i$ and $y(t) = \sum_{i=0}^{\deg y} y_i t^i$. The routines v_map() and zv_map() apply the function (*fn)() to the components of x to give the vector out. That is, out->ve[i] = (*fn)(x->ve[i]). There are also versions
VEC *_v_map(double (*fn)(void *,double),
void *fn_params, VEC *x, VEC *out)
ZVEC *_zv_map(complex (*fn)(void *,complex),
void *fn_params, ZVEC *x, ZVEC *out)
where out->ve[i] = (*fn)(fn_params,x->ve[i]).
This enables more flexible use of this function.
Both of these functions may be used in situ\/ with
x == out.
The routine v_max() returns the maximum entry of the vector
x, and sets index to be the index of this maximum value in
x.
Note that index is the index for the first\/ entry with this
value.
Thus max_x = v_max(x, &i) means that x->ve[i] == max_x.
The routine v_min() returns the minimum entry of the vector
x, and sets index to be the index of this minimum value
similarly to v_max().
Both v_min() and v_max() raise an E_SIZES error if
they are passed zero dimensional vectors.
The routines v_star() and zv_star() compute the
componentwise, or Hadamard, product of x and y.
That is, out->ve[i] = x->ve[i]*y->ve[i] for all i.
Note that v_star() is equivalent to multiplying y by a
diagonal matrix whose diagonal entries are given by the entries of
x.
This routine may be used in situ\/ with x == out.
The routines v_slash() and zv_slash() compute the
componentwise ratio of entries of y and x. (Note the order!)
That is, out->ve[i] = y->ve[i]/x->ve[i] for all i.
Note that this is equivalent to multiplying y by the inverse of the
diagonal matrix described in the previous paragraph.
This could be useful for preconditioning, for
example.
This routine may be used in situ\/ with x == out and/or
y == out.
The routine v_slash() raises an E_SING error if x has
a zero entry (the rationale being that it is really solving the system of
equations $Xz = y$ where $z$ is out).
The routine v_sort() sorts the entries of the vector x
in situ\/, and sets order to be the permutation that achieves
this.
Note that the old ordering of x can be obtained by using
pxinv_vec() as illustrated in the example below.
The algorithm used is a version of quicksort based on that given in
Algorithms in C, by R.~Sedgewick, pp.~116--124 (1990).
The routines v_sum() and zv_sum() return the sum of the
entries of x.
Note that there are no complex ``min'', ``max'' or ``sorting'' routines, as
there is no suitable ordering on the complex numbers.
EXAMPLE
An alternative way of computing $\|x\|_\infty$ (but slower):
VEC *x, *y, *z; PERM *order; Real norm; int i; ...... y = v_map(fabs,x,VNULL); norm = v_max(y,&i);Sorting a vector:
v_sort(x,order); /* x now sorted */ y = pxinv_vec(order,x,VNULL); /* y is now the original x */Using the Hadamard product for setting $y_i = w_i x_i$:
VEC *weights;
......
for ( i = 0; i < weights->dim; i++ )
weights->ve[i] = ...;
......
v_star(weights,x,y);
SEE ALSO: Other componentwise operations: v_add(), v_sub(), sv_mlt(). Iterative routines benefiting from diagonal preconditioning: iter_cg(), \newlineiter_cgs(), and iter_lsqr().
SOURCE FILE: vecop.c, zvecop.c