functions in soy.i -

            NT double_rco(&a)  
 
     Converts the float rco structure to double rco_d.  

            NT double_ruo(&a)  
 
     Converts the float ruo structure to double ruo_d.  

            NT float_rco(&a)  
 
     Converts the double rco_d structure to float rco.  

            NT float_ruo(&a)  
 
     Converts the double ruo_d structure to float ruo.  

            NT int(dims)  
 
     Interpolating operators implemented as sparse matrices.  
     "dims" is a dimension list with 2^i entries., example:  
     test = binop([64,32,16]) will return a 2-element pointer  
     array, each pointing to a 3-element array of RCO structures.  

            NT Laplace_FDA(CS,nact,aind)  
 
     Builds the discrete 2D Laplacian operator directly on RCO  
     format. Requires a bit of pre-processing (computing "aind"  
     - see aotest.i for how to do that).  

            NT Laplace_FDA2(ap,ur=,un=)  
 
     Same as Laplace_FDA, but MUCH faster. In fact, so fast that I  
     don't need to bother with going to a C implementation.  
     Input is a [0,1]-valued aperture function.  

            NT Laplace_FDA3(ap,ur=,un=)  
 
     Same as Laplace_FDA2, but with C implementation (faster).  
     Input is a [0,1]-valued aperture function.  

 rco  
 
struct rco  
{  
  int r;  
  int c;  
  int n;  
  pointer ix;  
  pointer jx;  
  pointer xn;  
  float t;  
}  

 rco_d  
 
struct rco_d  
{  
  int r;  
  int c;  
  int n;  
  pointer ix;  
  pointer jx;  
  pointer xn;  
  double t;  
}  

 rcoadd  
 

 rcoadd_double  
 

            NT func ruoadd(a,b,ur=,un=)  
 
     Sparse addition of two RUO matrices.  

 rcoata  
 

 rcoata_double  
 

            NT func rcoatb(a,b,ur=,un=,t=,u=)  
 
     Sparse mutiplication of two RCO matrices, a'.b. Setting u=1  
     ("upper") computes only the upper triangular and diagonal  
     elements of the matrix product, and returns an RUO matrix.  
     Use this when computing e.g. the final step of a 3-matrix  
     product of the type M = A'.W.A, where A is RCO, W is RUO  
     and you know that the final result must be RUO.  

 rcoatb  
 

 rcoatb2_float  
 

 rcoatb_double  
 

            NT func rcotr(arg)  
 
     Transposes an RCO matrix. Uses one builtin Yorick function  
     (sort) to make the rest a little bit easier.  

            NT func rcobuild(a,v,t,ur=,un=)  
 
     Appends a row-vector v to an RCO matrix a, at threshold t.  

            NT rcocc(&a,b)  
 
     Concatennate two RCO matrices row-wise  

            NT rcodr(a,r)  
 
     Delete a specific row from an RCO structure.  

            NT func rcoinf(a)  
 
     Inflates RCO compressed matrix to full form.  

            NT func rcos(a)  
 
     Computes the sparseness (or rather, the "fill") of a matrix on RCO format.  

 rcotr  
 

            NT func ruopcg(a,b,x0,&nit,tol=,itmax=,sgs=)  
 
     Preconditioned conjugate gradient solver for a symmetric positive  
     definite sparse linear system, with Jacobi preconditioner. This  
     algorithm is implemented straight out of Numerical Recipes, with  
     the matrix-vector multiplications carried out sparsely by the  
     ruoxv(a,v) function.  
     Optionally one may invoke symmetric Gauss-Seidel iterations upon  
     the Jacobi preconditioning, by setting the keyword sgs=#iters.  
     (at least 1). SGS requires the U, D and L to be externally defined.  

            NT func rcox(a,c)  
 
     Multiplies RCO compressed matrix by a scalar.  

            NT func rcoxv(a,v)  
 
     Sparse matrix-vector multiplication of RCO and real vector.  

 rcoxv_double  
 

            NT restore_rco(fn,bin=)  
 
     Returns the RCO structure saved in the file fn by save_rco.  

            NT restore_ruo(fn,bin=)  
 
     Returns the RUO structure saved in the file fn by save_rco.  

 ruo  
 
struct ruo  
{  
  int r;  
  int n;  
  pointer ix;  
  pointer jx;  
  pointer xn;  
  pointer xd;  
  float t;  
}  

            NT func ruo2rco(a)  
 
     Converts an RUO matrix into RCO. Calls both rcotr and rcoadd.  
     This is not very efficient, and should be used sparingly.  

 ruo_d  
 
struct ruo_d  
{  
  int r;  
  int n;  
  pointer ix;  
  pointer jx;  
  pointer xn;  
  pointer xd;  
  double t;  
}  

 ruoadd  
 

 ruoadd_double  
 

            NT func rcoata(a,ur=,un=,t=)  
 
     Sparse mutiplication of an RCO matrix with its transpose from  
     the left, i.e. transpose(a)##a  

            NT ruocc(&a,b)  
 
     Concatennate two RUO matrices block-diagonally  

            NT func ruoinf(a)  
 
     Inflates RUO compressed matrix to full form.  

 ruopcg  
 

            NT func ruos(a)  
 
     Computes the sparseness (or rather, the "fill") of a matrix on RUO format.  

            NT func ruox(a,c)  
 
     Multiplies RUO matrix "a" by a scalar "c".  

            NT func ruoxv(a,v)  
 
     Sparse matrix-vector multiplication of RUO and real vector.  

 ruoxv_double  
 

            NT func rcoadd(a,b,ur=,un=)  
 
     Sparse addition of two RCO matrices.  

            NT save_rco(a,fn,bin=)  
 
     Saves an RCO structure a to the binary file "fnX.bin" by converting  
     all of its elements to float (double) and putting them into a  
     single vector.  

            NT save_ruo(a,fn,bin=)  
 
     Saves an RUO structure a to the binary file fn by converting  
     all of its elements to float (double) and putting them into a  
     single vector.  

            NT spcon(&a,b,diag=,ruo=)  
 
     Concatennate two RCO matrices row-wise (default), diagonally  
     (diag=1), or two RUO matrices diagonally (ruo=1).  

            NT func spinfo(a)  
 
     Prints information about a sparse matrix in RCO or RUO format.  

            NT func sprco(x,t=,ur=,un=)  
 
     Compress a 2D matrix on sparse RCO format.  

 sprco_double  
 

            NT func spruo(x,t=,ur=,un=)  
 
     Compress a 2D matrix on sparse RUO format.  

 spruo_double