Creation routines for building Komplex matrices. More...

#include <stdlib.h>
#include <stdio.h>
#include "az_aztec.h"
#include "azk_komplex.h"

Include dependency graph for azk_create_matrix.c:

Functions
void	AZK_create_matrix_c2k (int options[], double params[], int proc_config[], AZ_MATRIX Amat_complex, AZ_MATRIX *Amat_komplex)
	Create Komplex matrix from Complex matrix. More...

void	AZK_create_matrix_c2k_fill_entry (int nrow, int ncol, double cur_complex, double cur_komplex)

void	AZK_create_matrix_g2k (int options[], double params[], int proc_config[], double c0r, double c0i, AZ_MATRIX Amat_mat0, double c1r, double c1i, AZ_MATRIX Amat_mat1, AZ_MATRIX **Amat_komplex)
	Create Komplex Matrix from General Matrix. More...

void	AZK_create_matrix_g2k_fill_entry (int nrow, int ncol, double c0r, double c0i, double mat0v, double c1r, double c1i, double mat1v, double *komplex)

void	AZK_create_matrix_ri2k (int options[], double params[], int proc_config[], AZ_MATRIX Amat_real, double val_imag, AZ_MATRIX **Amat_komplex)
	Create Komplex Matrix from Real and Imaginary Parts. More...

void	AZK_create_matrix_ri2k_fill_entry (int nrow, int ncol, double realv, double imagv, double *komplex)

Detailed Description

Creation routines for building Komplex matrices.

KOMPLEX is an add-on module to AZTEC that allows users to solve complex-valued linear systems.

KOMPLEX solves a complex-valued linear system Ax = b by solving an equivalent real-valued system of twice the dimension. Specifically, writing in terms of real and imaginary parts, we have

$(A_r + i*A_i)*(x_r + i*x_i) = (b_r + i*b_i)$

or by separating into real and imaginary equations we have

$\left( \begin{array}{rr} A_r & -A_i\\ A_i & A_r \end{array} \right) \left( \begin{array}{r} x_r\\ x_i \end{array} \right) = \left( \begin{array}{r} b_r\\ b_i \end{array} \right)$

which is a real-valued system of twice the size. If we find xr and xi, we can form the solution to the original system as x = xr +i*xi.

KOMPLEX accept user linear systems in three forms with either global or local index values.

1) The first form is true complex. The user passes in an MSR or VBR format matrix where the values are stored like Fortran complex numbers. Thus, the values array is of type double that is twice as long as the number of complex values. Each complex entry is stored with real part followed by imaginary part (as in Fortran).

2) The second form stores real and imaginary parts separately, but the pattern for each is identical. Thus only the values of the imaginary part are passed to the creation routines.

3) The third form accepts two real-valued matrices with no assumption about the structure of the matrices. Each matrix is multiplied by a user-supplied complex constant. This is the most general form.

Each of the above forms supports a global or local index set. By this we mean that the index values (stored in bindx) refer to the global problem indices, or the local indices (for example after calling AZ_transform).

Function Documentation

void AZK_create_matrix_c2k	(	int	options[],
		double	params[],
		int	proc_config[],
		AZ_MATRIX *	Amat_complex,
		AZ_MATRIX **	Amat_komplex
	)

Create Komplex matrix from Complex matrix.

Transforms a complex-valued matrix where double precision array hold the complex values of Amat_complex in Fortran complex format.

Parameters

options	(In) Determines specific solution method and other parameters.
params	(In) Drop tolerance and convergence tolerance info.
proc_config	(In) Machine configuration. proc_config[AZ_node] is the node number. proc_config[AZ_N_procs] is the number of processors.
Amat_complex	(In) An AZ_MATRIX structure where Amat_complex->val contain the values of the complex matrix in Fortran complex format.
Amat_komplex	(Out) Komplex version of matrix stored as an AZ_MATRIX structure.

Referenced by AZK_create_linsys_c2k().

void AZK_create_matrix_g2k	(	int	options[],
		double	params[],
		int	proc_config[],
		double	c0r,
		double	c0i,
		AZ_MATRIX *	Amat_mat0,
		double	c1r,
		double	c1i,
		AZ_MATRIX *	Amat_mat1,
		AZ_MATRIX **	Amat_komplex
	)

Create Komplex Matrix from General Matrix.

Transforms a complex-valued Matrix

(c0r+i*c0i)*A0 +(c1r+i*c1i)*A1)

to a Komplex matrix.

Parameters

options	(In) Determines specific solution method and other parameters.
params	(In) Drop tolerance and convergence tolerance info.
proc_config	(In) Machine configuration. proc_config[AZ_node] is the node number. proc_config[AZ_N_procs] is the number of processors.
c0r	(In) Real part of constant to be multiplied with first matrix.
c0i	(In) Imaginary part of constant to be multiplied with first matrix.
Amat_mat0	(In) AZ_MATRIX object containing first real-valued matrix.
c1r	(In) Real part of constant to be multiplied with second matrix.
c1i	(In) Imaginary part of constant to be multiplied with second matrix.
Amat_mat1	(In) AZ_MATRIX object containing second real-valued matrix.
Amat_komplex	(Out) Komplex version of matrix stored as an AZ_MATRIX structure.

Referenced by AZK_create_linsys_g2k().

void AZK_create_matrix_ri2k	(	int	options[],
		double	params[],
		int	proc_config[],
		AZ_MATRIX *	Amat_real,
		double *	val_imag,
		AZ_MATRIX **	Amat_komplex
	)

Create Komplex Matrix from Real and Imaginary Parts.

Transforms a complex-valued matrix

(Ar +i*Ai)

where double precision arrays hold the real and imaginary parts separately. The pattern of the imaginary part matches the real part. Thus no structure for the imaginary part is passed in.

Parameters

options	(In) Determines specific solution method and other parameters.
params	(In) Drop tolerance and convergence tolerance info.
proc_config	(In) Machine configuration. proc_config[AZ_node] is the node number. proc_config[AZ_N_procs] is the number of processors.
Amat_real	(In) AZ_MATRIX object containing real matrix.
val_imag	(In) Double arrya containing the values ONLY for imaginary matrix.
Amat_komplex	(Out) Komplex version of matrix stored as an AZ_MATRIX structure.

Referenced by AZK_create_linsys_ri2k().

Functions

Detailed Description

Function Documentation