int main(int argc, char **argv)
{
if (argc < 3)
{
fprintf(stderr, "Usage: zmake sourcefile_path zyncfile_path block_size\n");
return -1;
}
char *tail;
errno = 0;
zync_block_size_t block_size = (zync_block_size_t) strtol(argv[3], &tail, 0);
if (errno)
{
fprintf(stderr, "block_size Overflow\n");
return -1;
}
char *sourcefile_url = argv[1];
char *targetfile_url = argv[2];
int zmake_success = zmake(sourcefile_url, targetfile_url, block_size);
if (zmake_success < 0)
{
fprintf(stderr, "zmake returned %d\n", zmake_success);
}
return zmake_success;
}
/* zQRcondest -- returns an estimate of the 2-norm condition number of the
matrix factorised by QRfactor() or QRCPfactor()
-- note that as Q does not affect the 2-norm condition number,
it is not necessary to pass the diag, beta (or pivot) vectors
-- generates a lower bound on the true condition number
-- if the matrix is exactly singular, HUGE_VAL is returned
-- note that QRcondest() is likely to be more reliable for
matrices factored using QRCPfactor() */
double zQRcondest(ZMAT *QR)
{
STATIC ZVEC *y=ZVNULL;
Real norm, norm1, norm2, tmp1, tmp2;
complex sum, tmp;
int i, j, limit;
if ( QR == ZMNULL )
error(E_NULL,"zQRcondest");
limit = min(QR->m,QR->n);
for ( i = 0; i < limit; i++ )
/* if ( QR->me[i][i] == 0.0 ) */
if ( is_zero(QR->me[i][i]) )
return HUGE_VAL;
y = zv_resize(y,limit);
MEM_STAT_REG(y,TYPE_ZVEC);
/* use the trick for getting a unit vector y with ||R.y||_inf small
from the LU condition estimator */
for ( i = 0; i < limit; i++ )
{
sum.re = sum.im = 0.0;
for ( j = 0; j < i; j++ )
/* sum -= QR->me[j][i]*y->ve[j]; */
sum = zsub(sum,zmlt(QR->me[j][i],y->ve[j]));
/* sum -= (sum < 0.0) ? 1.0 : -1.0; */
norm1 = zabs(sum);
if ( norm1 == 0.0 )
sum.re = 1.0;
else
{
sum.re += sum.re / norm1;
sum.im += sum.im / norm1;
}
/* y->ve[i] = sum / QR->me[i][i]; */
y->ve[i] = zdiv(sum,QR->me[i][i]);
}
zUAmlt(QR,y,y);
/* now apply inverse power method to R*.R */
for ( i = 0; i < 3; i++ )
{
tmp1 = zv_norm2(y);
zv_mlt(zmake(1.0/tmp1,0.0),y,y);
zUAsolve(QR,y,y,0.0);
tmp2 = zv_norm2(y);
zv_mlt(zmake(1.0/tmp2,0.0),y,y);
zUsolve(QR,y,y,0.0);
}
/* now compute approximation for ||R^{-1}||_2 */
norm1 = sqrt(tmp1)*sqrt(tmp2);
/* now use complementary approach to compute approximation to ||R||_2 */
for ( i = limit-1; i >= 0; i-- )
{
sum.re = sum.im = 0.0;
for ( j = i+1; j < limit; j++ )
sum = zadd(sum,zmlt(QR->me[i][j],y->ve[j]));
if ( is_zero(QR->me[i][i]) )
return HUGE_VAL;
tmp = zdiv(sum,QR->me[i][i]);
if ( is_zero(tmp) )
{
y->ve[i].re = 1.0;
y->ve[i].im = 0.0;
}
else
{
norm = zabs(tmp);
y->ve[i].re = sum.re / norm;
y->ve[i].im = sum.im / norm;
}
/* y->ve[i] = (sum >= 0.0) ? 1.0 : -1.0; */
/* y->ve[i] = (QR->me[i][i] >= 0.0) ? y->ve[i] : - y->ve[i]; */
}
/* now apply power method to R*.R */
for ( i = 0; i < 3; i++ )
{
tmp1 = zv_norm2(y);
zv_mlt(zmake(1.0/tmp1,0.0),y,y);
zUmlt(QR,y,y);
tmp2 = zv_norm2(y);
zv_mlt(zmake(1.0/tmp2,0.0),y,y);
zUAmlt(QR,y,y);
}
norm2 = sqrt(tmp1)*sqrt(tmp2);
/* printf("QRcondest: norm1 = %g, norm2 = %g\n",norm1,norm2); */
#ifdef THREADSAFE
ZV_FREE(y);
#endif
return norm1*norm2;
}
