# Componentwise operations

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