int ssd_reverse(Quark *q)
{
ss_data *ssd = ssd_get_data(q);
int nrows, ncols, i, j, k;
if (!ssd) {
return RETURN_FAILURE;
}
nrows = ssd_get_nrows(q);
ncols = ssd_get_ncols(q);
for (k = 0; k < ncols; k++) {
ss_column *col = &ssd->cols[k];
if (col->format == FFORMAT_STRING) {
char **s = col->data;
for (i = 0; i < nrows/2; i++) {
j = (nrows - 1) - i;
sswap(&s[i], &s[j]);
}
} else {
double *x = col->data;
for (i = 0; i < nrows/2; i++) {
j = (nrows - 1) - i;
fswap(&x[i], &x[j]);
}
}
}
quark_dirtystate_set(q, TRUE);
return RETURN_SUCCESS;
}
void IntervalFilter::add(uint16 from, uint16 to)
{
if (from > MAX_ID)
{
from = MAX_ID;
}
if (to > MAX_ID)
{
to = MAX_ID;
}
//assert order
if (from > to)
{
sswap(from, to);
}
//adjust lower bound
fFrom = smin(fFrom, from);
//adjust upper bound
fTo = smax(fTo, to);
}
void
sqrdc (float **x, int n, int p, float *qraux, int *jpvt,
float *work, int job)
/*****************************************************************************
Use Householder transformations to compute the QR decomposition of an n by p
matrix x. Column pivoting based on the 2-norms of the reduced columns may be
performed at the user's option.
******************************************************************************
Input:
x matrix[p][n] to decompose (see notes below)
n number of rows in the matrix x
p number of columns in the matrix x
jpvt array[p] controlling the pivot columns (see notes below)
job =0 for no pivoting;
=1 for pivoting
Output:
x matrix[p][n] decomposed (see notes below)
qraux array[p] containing information required to recover the
orthogonal part of the decomposition
jpvt array[p] with jpvt[k] containing the index of the original
matrix that has been interchanged into the k-th column, if
pivoting is requested.
Workspace:
work array[p] of workspace
******************************************************************************
Notes:
This function was adapted from LINPACK FORTRAN. Because two-dimensional
arrays cannot be declared with variable dimensions in C, the matrix x
is actually a pointer to an array of pointers to floats, as declared
above and used below.
Elements of x are stored as follows:
x[0][0] x[1][0] x[2][0] ... x[p-1][0]
x[0][1] x[1][1] x[2][1] ... x[p-1][1]
x[0][2] x[1][2] x[2][2] ... x[p-1][2]
. .
. . .
. . .
. .
x[0][n-1] x[1][n-1] x[2][n-1] ... x[p-1][n-1]
After decomposition, x contains in its upper triangular matrix R of the QR
decomposition. Below its diagonal x contains information from which the
orthogonal part of the decomposition can be recovered. Note that if
pivoting has been requested, the decomposition is not that of the original
matrix x but that of x with its columns permuted as described by jpvt.
The selection of pivot columns is controlled by jpvt as follows.
The k-th column x[k] of x is placed in one of three classes according to
the value of jpvt[k].
if jpvt[k] > 0, then x[k] is an initial column.
if jpvt[k] == 0, then x[k] is a free column.
if jpvt[k] < 0, then x[k] is a final column.
Before the decomposition is computed, initial columns are moved to the
beginning of the array x and final columns to the end. Both initial and
final columns are frozen in place during the computation and only free
columns are moved. At the k-th stage of the reduction, if x[k] is occupied
by a free column it is interchanged with the free column of largest reduced
norm. jpvt is not referenced if job == 0.
******************************************************************************
Author: Dave Hale, Colorado School of Mines, 12/29/89
*****************************************************************************/
{
int j,jp,l,lup,maxj,pl,pu,negj,swapj;
float maxnrm,t,tt,ttt,nrmxl;
pl = 0;
pu = -1;
/* if pivoting has been requested */
if (job!=0) {
/* rearrange columns according to jpvt */
for (j=0; j<p; j++) {
swapj = jpvt[j]>0;
negj = jpvt[j]<0;
jpvt[j] = j;
if (negj) jpvt[j] = -j;
if (swapj) {
if (j!=pl) sswap(n,x[pl],1,x[j],1);
jpvt[j] = jpvt[pl];
jpvt[pl] = j;
pl++;
}
}
pu = p-1;
for (j=p-1; j>=0; j--) {
if (jpvt[j]<0) {
jpvt[j] = -jpvt[j];
if (j!=pu) {
sswap(n,x[pu],1,x[j],1);
jp = jpvt[pu];
jpvt[pu] = jpvt[j];
jpvt[j] = jp;
}
pu--;
}
}
}
/* compute the norms of the free columns */
for (j=pl; j<=pu; j++) {
qraux[j] = snrm2(n,x[j],1);
work[j] = qraux[j];
}
/* perform the Householder reduction of x */
lup = MIN(n,p);
for (l=0; l<lup; l++) {
if (l>=pl && l<pu) {
/*
* locate the column of largest norm and
* bring it into pivot position.
*/
maxnrm = 0.0;
maxj = l;
for (j=l; j<=pu; j++) {
if (qraux[j]>maxnrm) {
maxnrm = qraux[j];
maxj = j;
}
}
if (maxj!=l) {
sswap(n,x[l],1,x[maxj],1);
qraux[maxj] = qraux[l];
work[maxj] = work[l];
jp = jpvt[maxj];
jpvt[maxj] = jpvt[l];
jpvt[l] = jp;
}
}
qraux[l] = 0.0;
if (l!=n-1) {
/*
* compute the Householder transformation
* for column l
*/
nrmxl = snrm2(n-l,&x[l][l],1);
if (nrmxl!=0.0) {
if (x[l][l]!=0.0)
nrmxl = (x[l][l]>0.0) ?
ABS(nrmxl) :
-ABS(nrmxl);
sscal(n-l,1.0/nrmxl,&x[l][l],1);
x[l][l] += 1.0;
/*
* apply the transformation to the remaining
* columns, updating the norms
*/
for (j=l+1; j<p; j++) {
t = -sdot(n-l,&x[l][l],1,&x[j][l],1)/
x[l][l];
saxpy(n-l,t,&x[l][l],1,&x[j][l],1);
if (j>=pl && j<=pu && qraux[j]!=0.0) {
tt = ABS(x[j][l])/qraux[j];
tt = 1.0-tt*tt;
tt = MAX(tt,0.0);
t = tt;
ttt = qraux[j]/work[j];
tt = 1.0+0.05*tt*ttt*ttt;
if (tt!=1.0) {
qraux[j] *= sqrt(t);
} else {
qraux[j] = snrm2(n-l-1,
&x[j][l+1],1);
work[j] = qraux[j];
}
}
}
/* save the transformation */
qraux[l] = x[l][l];
x[l][l] = -nrmxl;
}
}
}
}
main()
{
int i,n=N;
printf("isamax = %d\n",isamax(n,sx,1));
printf("isamax = %d\n",isamax(n/2,sx,2));
printf("isamax = %d\n",isamax(n,sy,1));
printf("sasum = %g\n",sasum(n,sx,1));
printf("sasum = %g\n",sasum(n/2,sx,2));
printf("sasum = %g\n",sasum(n,sy,1));
printf("snrm2 = %g\n",snrm2(n,sx,1));
printf("snrm2 = %g\n",snrm2(n/2,sx,2));
printf("snrm2 = %g\n",snrm2(n,sy,1));
printf("sdot = %g\n",sdot(n,sx,1,sy,1));
printf("sdot = %g\n",sdot(n/2,sx,2,sy,2));
printf("sdot = %g\n",sdot(n/2,sx,-2,sy,2));
printf("sdot = %g\n",sdot(n,sy,1,sy,1));
printf("sscal\n");
sscal(n,2.0,sx,1);
pvec(n,sx);
sscal(n,0.5,sx,1);
pvec(n,sx);
sscal(n/2,2.0,sx,2);
pvec(n,sx);
sscal(n/2,0.5,sx,2);
pvec(n,sx);
printf("sswap\n");
sswap(n,sx,1,sy,1);
pvec(n,sx); pvec(n,sy);
sswap(n,sy,1,sx,1);
pvec(n,sx); pvec(n,sy);
sswap(n/2,sx,1,sx+n/2,-1);
pvec(n,sx);
sswap(n/2,sx,1,sx+n/2,-1);
pvec(n,sx);
sswap(n/2,sx,2,sy,2);
pvec(n,sx); pvec(n,sy);
sswap(n/2,sx,2,sy,2);
pvec(n,sx); pvec(n,sy);
printf("saxpy\n");
saxpy(n,2.0,sx,1,sy,1);
pvec(n,sx); pvec(n,sy);
saxpy(n,-2.0,sx,1,sy,1);
pvec(n,sx); pvec(n,sy);
saxpy(n/2,2.0,sx,2,sy,2);
pvec(n,sx); pvec(n,sy);
saxpy(n/2,-2.0,sx,2,sy,2);
pvec(n,sx); pvec(n,sy);
saxpy(n/2,2.0,sx,-2,sy,1);
pvec(n,sx); pvec(n,sy);
saxpy(n/2,-2.0,sx,-2,sy,1);
pvec(n,sx); pvec(n,sy);
printf("scopy\n");
scopy(n/2,sx,2,sy,2);
pvec(n,sx); pvec(n,sy);
scopy(n/2,sx+1,2,sy+1,2);
pvec(n,sx); pvec(n,sy);
scopy(n/2,sx,2,sy,1);
pvec(n,sx); pvec(n,sy);
scopy(n/2,sx+1,-2,sy+n/2,-1);
pvec(n,sx); pvec(n,sy);
}
int msgefa2 ( float a[], int lda, int n, int ipvt[] )
/******************************************************************************/
/*
Purpose:
MSGEFA2 factors a matrix by gaussian elimination.
Discussion:
Matrix references which would, mathematically, be written A(I,J)
must be written here as:
* A[I+J*LDA], when the value is needed, or
* A+I+J*LDA, when the address is needed.
This variant of SGEFA uses OpenMP for improved parallel execution.
The step in which multiples of the pivot row are added to individual
rows has been replaced by a single call which updates the entire
matrix sub-block.
Modified:
07 March 2008
Author:
FORTRAN77 original version by Cleve Moler.
C version by Wesley Petersen.
Reference:
Jack Dongarra, Jim Bunch, Cleve Moler, Pete Stewart,
LINPACK User's Guide,
SIAM, 1979,
ISBN13: 978-0-898711-72-1,
LC: QA214.L56.
Parameters:
Input/output, float A[LDA*N]. On input, the matrix to be factored.
On output, an upper triangular matrix and the multipliers which were
used to obtain it. The factorization can be written A = L * U where
L is a product of permutation and unit lower triangular matrices and
U is upper triangular.
Input, int LDA, the leading dimension of the matrix.
Input, int N, the order of the matrix.
Output, int IPVT[N], the pivot indices.
Output, int MSGEFA, indicates singularity.
If 0, this is the normal value, and the algorithm succeeded.
If K, then on the K-th elimination step, a zero pivot was encountered.
The matrix is numerically not invertible.
*/
{
int info;
int k,kp1,l,nm1;
float t;
info = 0;
nm1 = n - 1;
for ( k = 0; k < nm1; k++ )
{
kp1 = k + 1;
l = isamax ( n-k, a+k+k*lda, 1 ) + k - 1;
ipvt[k] = l + 1;
if ( a[l+k*lda] == 0.0 )
{
info = k + 1;
return info;
}
if ( l != k )
{
t = a[l+k*lda];
a[l+k*lda] = a[k+k*lda];
a[k+k*lda] = t;
}
t = -1.0 / a[k+k*lda];
sscal ( n-k-1, t, a+kp1+k*lda, 1 );
/*
Interchange the pivot row and the K-th row.
*/
if ( l != k )
{
sswap ( n-k-1, a+l+kp1*lda, lda, a+k+kp1*lda, lda );
}
/*
Add multiples of the K-th row to rows K+1 through N.
*/
msaxpy2 ( n-k-1, n-k-1, a+k+kp1*lda, n, a+kp1+k*lda, a+kp1+kp1*lda );
}
ipvt[n-1] = n;
if ( a[n-1+(n-1)*lda] == 0.0 )
{
info = n;
}
return info;
}
