umfpack_report_matrix.h
6.83 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
/* ========================================================================== */
/* === umfpack_report_matrix ================================================ */
/* ========================================================================== */
/* -------------------------------------------------------------------------- */
/* UMFPACK Copyright (c) Timothy A. Davis, CISE, */
/* Univ. of Florida. All Rights Reserved. See ../Doc/License for License. */
/* web: http://www.cise.ufl.edu/research/sparse/umfpack */
/* -------------------------------------------------------------------------- */
int umfpack_di_report_matrix
(
int n_row,
int n_col,
const int Ap [ ],
const int Ai [ ],
const double Ax [ ],
int col_form,
const double Control [UMFPACK_CONTROL]
) ;
UF_long umfpack_dl_report_matrix
(
UF_long n_row,
UF_long n_col,
const UF_long Ap [ ],
const UF_long Ai [ ],
const double Ax [ ],
UF_long col_form,
const double Control [UMFPACK_CONTROL]
) ;
int umfpack_zi_report_matrix
(
int n_row,
int n_col,
const int Ap [ ],
const int Ai [ ],
const double Ax [ ], const double Az [ ],
int col_form,
const double Control [UMFPACK_CONTROL]
) ;
UF_long umfpack_zl_report_matrix
(
UF_long n_row,
UF_long n_col,
const UF_long Ap [ ],
const UF_long Ai [ ],
const double Ax [ ], const double Az [ ],
UF_long col_form,
const double Control [UMFPACK_CONTROL]
) ;
/*
double int Syntax:
#include "umfpack.h"
int n_row, n_col, *Ap, *Ai, status ;
double *Ax, Control [UMFPACK_CONTROL] ;
status = umfpack_di_report_matrix (n_row, n_col, Ap, Ai, Ax, 1, Control) ;
or:
status = umfpack_di_report_matrix (n_row, n_col, Ap, Ai, Ax, 0, Control) ;
double UF_long Syntax:
#include "umfpack.h"
UF_long n_row, n_col, *Ap, *Ai, status ;
double *Ax, Control [UMFPACK_CONTROL] ;
status = umfpack_dl_report_matrix (n_row, n_col, Ap, Ai, Ax, 1, Control) ;
or:
status = umfpack_dl_report_matrix (n_row, n_col, Ap, Ai, Ax, 0, Control) ;
complex int Syntax:
#include "umfpack.h"
int n_row, n_col, *Ap, *Ai, status ;
double *Ax, *Az, Control [UMFPACK_CONTROL] ;
status = umfpack_zi_report_matrix (n_row, n_col, Ap, Ai, Ax, Az, 1,
Control) ;
or:
status = umfpack_zi_report_matrix (n_row, n_col, Ap, Ai, Ax, Az, 0,
Control) ;
complex UF_long Syntax:
#include "umfpack.h"
UF_long n_row, n_col, *Ap, *Ai, status ;
double *Ax, Control [UMFPACK_CONTROL] ;
status = umfpack_zl_report_matrix (n_row, n_col, Ap, Ai, Ax, Az, 1,
Control) ;
or:
status = umfpack_zl_report_matrix (n_row, n_col, Ap, Ai, Ax, Az, 0,
Control) ;
packed complex Syntax:
Same as above, except Az is NULL.
Purpose:
Verifies and prints a row or column-oriented sparse matrix.
Returns:
UMFPACK_OK if Control [UMFPACK_PRL] <= 2 (the input is not checked).
Otherwise (where n is n_col for the column form and n_row for row
and let ni be n_row for the column form and n_col for row):
UMFPACK_OK if the matrix is valid.
UMFPACK_ERROR_n_nonpositive if n_row <= 0 or n_col <= 0.
UMFPACK_ERROR_argument_missing if Ap and/or Ai are missing.
UMFPACK_ERROR_invalid_matrix if Ap [n] < 0, if Ap [0] is not zero,
if Ap [j+1] < Ap [j] for any j in the range 0 to n-1,
if any row index in Ai is not in the range 0 to ni-1, or
if the row indices in any column are not in
ascending order, or contain duplicates.
UMFPACK_ERROR_out_of_memory if out of memory.
Arguments:
Int n_row ; Input argument, not modified.
Int n_col ; Input argument, not modified.
A is an n_row-by-n_row matrix. Restriction: n_row > 0 and n_col > 0.
Int Ap [n+1] ; Input argument, not modified.
n is n_row for a row-form matrix, and n_col for a column-form matrix.
Ap is an integer array of size n+1. If col_form is true (nonzero),
then on input, it holds the "pointers" for the column form of the
sparse matrix A. The row indices of column j of the matrix A are held
in Ai [(Ap [j]) ... (Ap [j+1]-1)]. Otherwise, Ap holds the
row pointers, and the column indices of row j of the matrix are held
in Ai [(Ap [j]) ... (Ap [j+1]-1)].
The first entry, Ap [0], must be zero, and Ap [j] <= Ap [j+1] must hold
for all j in the range 0 to n-1. The value nz = Ap [n] is thus the
total number of entries in the pattern of the matrix A.
Int Ai [nz] ; Input argument, not modified, of size nz = Ap [n].
If col_form is true (nonzero), then the nonzero pattern (row indices)
for column j is stored in Ai [(Ap [j]) ... (Ap [j+1]-1)]. Row indices
must be in the range 0 to n_row-1 (the matrix is 0-based).
Otherwise, the nonzero pattern (column indices) for row j is stored in
Ai [(Ap [j]) ... (Ap [j+1]-1)]. Column indices must be in the range 0
to n_col-1 (the matrix is 0-based).
double Ax [nz] ; Input argument, not modified, of size nz = Ap [n].
Size 2*nz for packed complex case.
The numerical values of the sparse matrix A.
If col_form is true (nonzero), then the nonzero pattern (row indices)
for column j is stored in Ai [(Ap [j]) ... (Ap [j+1]-1)], and the
corresponding (real) numerical values are stored in
Ax [(Ap [j]) ... (Ap [j+1]-1)]. The imaginary parts are stored in
Az [(Ap [j]) ... (Ap [j+1]-1)], for the complex versions
(see below if Az is NULL).
Otherwise, the nonzero pattern (column indices) for row j
is stored in Ai [(Ap [j]) ... (Ap [j+1]-1)], and the corresponding
(real) numerical values are stored in Ax [(Ap [j]) ... (Ap [j+1]-1)].
The imaginary parts are stored in Az [(Ap [j]) ... (Ap [j+1]-1)],
for the complex versions (see below if Az is NULL).
No numerical values are printed if Ax is NULL.
double Az [nz] ; Input argument, not modified, for complex versions.
The imaginary values of the sparse matrix A. See the description
of Ax, above.
If Az is NULL, then both real
and imaginary parts are contained in Ax[0..2*nz-1], with Ax[2*k]
and Ax[2*k+1] being the real and imaginary part of the kth entry.
Int col_form ; Input argument, not modified.
The matrix is in row-oriented form if form is col_form is false (0).
Otherwise, the matrix is in column-oriented form.
double Control [UMFPACK_CONTROL] ; Input argument, not modified.
If a (double *) NULL pointer is passed, then the default control
settings are used. Otherwise, the settings are determined from the
Control array. See umfpack_*_defaults on how to fill the Control
array with the default settings. If Control contains NaN's, the
defaults are used. The following Control parameters are used:
Control [UMFPACK_PRL]: printing level.
2 or less: no output. returns silently without checking anything.
3: fully check input, and print a short summary of its status
4: as 3, but print first few entries of the input
5: as 3, but print all of the input
Default: 1
*/