void SWAP(long k, long k1, long kmax, long n, verylong *zd, verylong **zb, verylong **zh, verylong **zl) { long i, j; verylong zB = 0, zm = 0, zr = 0, zs = 0, zt = 0; verylong zu = 0; for (i = 1; i <= n; i++) { zcopy(zh[i][k], &zt); zcopy(zh[i][k1], &zh[i][k]); zcopy(zt, &zh[i][k1]); } for (j = 1; j <= n; j++) { zcopy(zb[k][j], &zt); zcopy(zb[k1][j], &zb[k][j]); zcopy(zt, &zb[k1][j]); } if (k > 2) { for (j = 1; j <= k - 2; j++) { zcopy(zl[k][j], &zt); zcopy(zl[k1][j], &zl[k][j]); zcopy(zt, &zl[k1][j]); } } zcopy(zl[k][k1], &zm); zmul(zd[k - 2], zd[k], &zr); zsq(zm, &zs); zadd(zr, zs, &zt); zdiv(zt, zd[k1], &zB, &zr); for (i = k + 1; i <= kmax; i++) { zcopy(zl[i][k], &zt); zmul(zd[k], zl[i][k1], &zr); zmul(zm, zt, &zs); zsub(zr, zs, &zu); zdiv(zu, zd[k1], &zl[i][k], &zr); zmul(zB, zt, &zr); zmul(zm, zl[i][k], &zs); zadd(zr, zs, &zu); zdiv(zu, zd[k], &zl[i][k1], &zr); } zcopy(zB, &zd[k1]); zfree(&zB); zfree(&zm); zfree(&zr); zfree(&zs); zfree(&zt); zfree(&zu); }
fint prntract_c( fint *pnum, fchar fnam, fint *rem ) { fint r; /* status */ r = iniprinter( ); /* initialize printer buffer */ if (r > -1) { /* no errors so far */ if ( *pnum > 0 && *pnum <= r ) { /* legal printer number */ char cmd[MAXTEXTLEN]; /* buffer for print command */ char *file; /* pointer to file name */ fint p = (*pnum - 1); /* pointer in buffer */ file = zadd( fnam ); /* zero terminates string */ (void) sprintf( cmd, prntrs[p].cmd, file ); (void) system( cmd ); /* do the print */ if (*rem) { /* remove file ? */ remove( file ); /* do it */ } free( file ); /* free memory */ r = 0; /* no error */ } else { /* no such printer */ r = -10; /* set status */ } } return( r ); /* return status */ }
fint filestat_c( fchar filename , fint *atime , fint *mtime , fint *ftype ) { char *path; fint r = 0; struct stat buf; path = zadd( filename ); r = stat( path, &buf ); if (!r) { (*atime) = (fint) buf.st_atime; (*mtime) = (fint) buf.st_mtime; if ((buf.st_mode & S_IFMT) == S_IFREG) { (*ftype) = 1; } else if ((buf.st_mode & S_IFMT) == S_IFDIR) { (*ftype) = 2; } else { (*ftype) = 0; } free( path ); } return( r ); }
void Garner(long t, verylong *zm, verylong *zv, verylong *zx) /* solution of the Chinese remaider theorem */ { long i, j; verylong za = 0, zb = 0, zu = 0, zC[CRT_SIZE]; for (i = 0; i < CRT_SIZE; i++) zC[i] = 0; for (i = 1; i < t; i++) { zone(&zC[i]); for (j = 0; j <= i - 1; j++) { zinvmod(zm[j], zm[i], &zu); zmulmod(zu, zC[i], zm[i], &za); zcopy(za, &zC[i]); } } zcopy(zv[0], &zu); zcopy(zu, zx); for (i = 1; i < t; i++) { zsub(zv[i], *zx, &za); zmulmod(za, zC[i], zm[i], &zu); zone(&za); for (j = 0; j <= i - 1; j++) { zmul(za, zm[j], &zb); zcopy(zb, &za); } zmul(za, zu, &zb); zadd(*zx, zb, &za); zcopy(za, zx); } zfree(&za); zfree(&zb); zfree(&zu); for (i = 0; i < CRT_SIZE; i++) zfree(&zC[i]); }
void Montgomery_multiplication(long b, long n, verylong zm, verylong zx, verylong zy, verylong *zA) { long i, n1 = n + 1, u, mp, *a, *m, *x, *y; verylong za = 0, zb = 0, zc = 0, zd = 0, zs = 0; a = calloc(n1, sizeof(long)); m = calloc(n1, sizeof(long)); x = calloc(n1, sizeof(long)); y = calloc(n1, sizeof(long)); if (a == 0 || m == 0 || x == 0 || y == 0) { printf("*error*\ncan't get memory from Montgomery"); printf(" multiplication"); exit(1); } zintoz(b, &zb); zinvmod(zm, zb, &za); znegate(&za); mp = zsmod(za, b); radix_representation(b, n1, m, zm); radix_representation(b, n1, x, zx); radix_representation(b, n1, y, zy); zzero(zA); for (i = 0; i < n; i++) { radix_representation(b, n1, a, *zA); u = ((a[0] + x[i] * y[0]) * mp) % b; zsmul(zy, x[i], &za); zsmul(zm, u, &zc); zadd(*zA, za, &zs); zadd(zs, zc, &zd); zsdiv(zd, b, zA); } if (zcompare(*zA, zm) >= 0) { zsub(*zA, zm, &za); zcopy(za, zA); } free(a); free(m); free(x); free(y); zfree(&za); zfree(&zb); zfree(&zc); zfree(&zd); zfree(&zs); }
/* * GEOADD key MERCATOR|WGS84 x y value [x y value....] */ int Ardb::GeoAdd(Context& ctx, RedisCommandFrame& cmd) { GeoAddOptions options; std::string err; if (0 != options.Parse(cmd.GetArguments(), err, 1)) { fill_error_reply(ctx.reply, "%s", err.c_str()); return 0; } GeoHashRange lat_range, lon_range; GeoHashHelper::GetCoordRange(options.coord_type, lat_range, lon_range); KeyLockerGuard keylock(m_key_lock, ctx.currentDB, cmd.GetArguments()[0]); ValueObject meta; int ret = GetMetaValue(ctx, cmd.GetArguments()[0], ZSET_META, meta); CHECK_ARDB_RETURN_VALUE(ctx.reply, ret); RedisCommandFrame zadd("zadd"); zadd.AddArg(cmd.GetArguments()[0]); BatchWriteGuard guard(GetKeyValueEngine()); GeoPointArray::iterator git = options.points.begin(); uint32 count = 0; while (git != options.points.end()) { GeoPoint& point = *git; if (point.x < lon_range.min || point.x > lon_range.max || point.y < lat_range.min || point.y > lat_range.max) { guard.MarkFailed(); break; } GeoHashBits hash; geohash_encode(&lat_range, &lon_range, point.y, point.x, 30, &hash); GeoHashFix60Bits score = hash.bits; Data score_value; score_value.SetInt64((int64) score); Data element; element.SetString(point.value, true); count += ZSetAdd(ctx, meta, element, score_value, NULL); std::string tmp; score_value.GetDecodeString(tmp); zadd.AddArg(tmp); element.GetDecodeString(tmp); zadd.AddArg(tmp); git++; } if (guard.Success()) { SetKeyValue(ctx, meta); RewriteClientCommand(ctx, zadd); fill_int_reply(ctx.reply, count); } else { fill_error_reply(ctx.reply, "Invalid arguments"); } return 0; }
void scalar(long n, verylong *za, verylong *zb, verylong *zs) { /* *s = inner_product(a, b) */ long i; verylong zt = 0, zu = 0; zzero(zs); for (i = 1; i <= n; i++) { zmul(za[i], zb[i], &zt); zadd(zt, *zs, &zu); zcopy(zu, zs); } zfree(&zt); zfree(&zu); }
void RED(long k, long l, long n, verylong *zd, verylong **zb, verylong **zh, verylong **zl) { long i; verylong zq = 0, zr = 0, zs = 0, zt = 0; zlshift(zl[k][l], 1l, &zr); zcopy(zr, &zs); zabs(&zs); if (zcompare(zs, zd[l]) > 0) { zadd(zr, zd[l], &zs); zlshift(zd[l], 1l, &zr); zdiv(zs, zr, &zq, &zt); for (i = 1; i <= n; i++) { zmul(zq, zh[i][l], &zr); zsub(zh[i][k], zr, &zs); zcopy(zs, &zh[i][k]); zmul(zq, zb[l][i], &zr); zsub(zb[k][i], zr, &zs); zcopy(zs, &zb[k][i]); } zmul(zq, zd[l], &zr); zsub(zl[k][l], zr, &zs); zcopy(zs, &zl[k][l]); for (i = 1; i <= l - 1; i++) { zmul(zq, zl[l][i], &zr); zsub(zl[k][i], zr, &zs); zcopy(zs, &zl[k][i]); } } zfree(&zq); zfree(&zr); zfree(&zs); zfree(&zt); }
int main(void) { /* static because otherwise it would have to be volatile yeilding a lot of stupid * warnings. auto variables are not guaranteed to be readable after a long jump. */ static z_t a, b, c, d, _0, _1, _2, _3; static char buf[2000]; static int ret = 0; static jmp_buf env, env2; static size_t n; #define BUF_N (sizeof(buf) - 1) if (setjmp(env)) { zperror(0); ret = 2; goto done; } zsetup(env); zinit(a), zinit(b), zinit(c), zinit(d), zinit(_0), zinit(_1), zinit(_2), zinit(_3); zsetu(_0, 0); zsetu(_1, 1); zsetu(_2, 2); zsetu(_3, 3); assert(zeven(_0), == 1); assert(zodd(_0), == 0); assert(zzero(_0), == 1); assert(zsignum(_0), == 0); assert(zeven(_1), == 0); assert(zodd(_1), == 1); assert(zzero(_1), == 0); assert(zsignum(_1), == 1); assert(zeven(_2), == 1); assert(zodd(_2), == 0); assert(zzero(_2), == 0); assert(zsignum(_2), == 1); zswap(_1, _2); assert(zeven(_2), == 0); assert(zodd(_2), == 1); assert(zzero(_2), == 0); assert(zsignum(_2), == 1); assert(zeven(_1), == 1); assert(zodd(_1), == 0); assert(zzero(_1), == 0); assert(zsignum(_1), == 1); zswap(_2, _1); assert(zeven(_1), == 0); assert(zodd(_1), == 1); assert(zzero(_1), == 0); assert(zsignum(_1), == 1); assert(zeven(_2), == 1); assert(zodd(_2), == 0); assert(zzero(_2), == 0); assert(zsignum(_2), == 1); assert((zneg(_2, _2), zsignum(_2)), == -1); zneg(_2, _2); assert(zsignum(_2), == 1); assert(zcmp(_0, _0), == 0); assert(zcmp(_1, _1), == 0); assert(zcmp(_0, _1), < 0); assert(zcmp(_1, _0), > 0); assert(zcmp(_1, _2), < 0); assert(zcmp(_2, _1), > 0); assert(zcmp(_0, _2), < 0); assert(zcmp(_2, _0), > 0); zbset(a, _0, 0, 1); assert(zcmp(a, _1), == 0); zbset(a, a, 1, 1); assert(zcmp(a, _3), == 0); zbset(a, a, 0, 0); assert(zcmp(a, _2), == 0); zbset(a, a, 0, 0); assert(zcmp(a, _2), == 0); zbset(a, a, 0, -1); assert(zcmp(a, _3), == 0); zbset(a, a, 0, -1); assert(zcmp(a, _2), == 0); zadd(a, _0, _1); assert(zsignum(a), == 1); assert(zcmp(a, _1), == 0); assert(zcmpi(a, 1), == 0); assert(zcmpu(a, 1), == 0); zneg(a, a); assert(zsignum(a), == -1); assert(zcmp(a, _1), < 0); assert(zcmpi(a, 1), < 0); assert(zcmpu(a, 1), < 0); zadd(a, _2, _0); assert(zsignum(a), == 1); assert(zcmp(a, _2), == 0); assert(zcmpi(a, 2), == 0); assert(zcmpu(a, 2), == 0); zneg(a, a); assert(zsignum(a), == -1); assert(zcmp(a, _2), < 0); assert(zcmpi(a, 2), < 0); assert(zcmpu(a, 2), < 0); assert(zsignum(_1), == 1); zadd(a, _1, _1); assert(zsignum(a), == 1); assert(zcmp(a, _2), == 0); assert(zcmpi(a, 2), == 0); assert(zcmpu(a, 2), == 0); zset(b, _1); zadd(a, b, _1); assert(zsignum(a), == 1); assert(zcmp(a, _2), == 0); assert(zcmpi(a, 2), == 0); assert(zcmpu(a, 2), == 0); zneg(a, a); zset(b, _2); zneg(b, b); assert(zsignum(a), == -1); assert(zcmp(a, b), == 0); assert(zcmp(a, _2), < 0); assert(zcmpmag(a, b), == 0); assert(zcmpmag(a, _2), == 0); assert(zcmpi(a, 2), < 0); assert(zcmpu(a, 2), < 0); assert(zcmpi(a, -2), == 0); assert((zneg(_2, _2), zcmp(a, _2)), == 0); zneg(_2, _2); zadd(a, _1, _2); assert(zsignum(a), == 1); assert(zcmp(a, _2), > 0); assert(zcmpi(a, 2), > 0); assert(zcmpu(a, 2), > 0); zneg(a, a); zset(b, _2); zneg(b, b); assert(zsignum(a), == -1); assert(zcmpmag(a, _2), > 0); assert(zcmpmag(a, b), > 0); assert(zcmp(a, b), < 0); assert(zcmp(a, _2), < 0); assert(zcmpi(a, 2), < 0); assert(zcmpu(a, 2), < 0); assert(zcmpi(a, -2), < 0); assert((zneg(_2, _2), zcmp(a, _2)), < 0); zneg(_2, _2); zneg(b, _3); assert(zcmp(a, b), == 0); zunsetup(); zsetup(env); zsub(a, _2, _1); assert(zcmpmag(_2, _1), > 0); assert(zcmpmag(_2, _0), > 0); assert(zcmpmag(_1, _0), > 0); zsub(b, _1, _2); assert(zcmpmag(_2, _0), > 0); assert(zcmpmag(_1, _0), > 0); assert(zcmpmag(_2, _1), > 0); assert(zcmpmag(a, b), == 0); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, b), > 0); assert(zcmp(a, _1), == 0); assert(zcmp(b, _1), < 0); zsub(a, _1, _1); assert(zcmp(a, _0), == 0); zseti(b, 0); zsetu(c, 0); zsub(a, b, c); assert(zcmp(a, _0), == 0); assert(zcmpmag(_2, _1), > 0); assert(zcmp(_2, _1), > 0); zsub(a, _2, _1); assert(zsignum(a), == 1); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), == 0); zsub(a, a, _1); assert(zcmp(a, _0), == 0); zsub(a, a, _0); assert(zcmp(a, _0), == 0); zsub(a, _1, _2); assert(zcmp(a, _1), < 0); assert(zcmpmag(a, _1), == 0); zabs(a, a); assert(zcmp(a, _1), == 0); zabs(a, a); assert(zcmp(a, _1), == 0); zabs(a, _1); assert(zcmp(a, _1), == 0); zabs(a, _0); assert(zcmp(a, _0), == 0); zseti(b, -1); zseti(c, -2); zadd(a, _0, b); assert(zcmp(a, _0), < 0); assert(zcmpi(a, -1), == 0); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), < 0); zadd(a, b, _0); assert(zcmp(a, _0), < 0); assert(zcmpi(a, -1), == 0); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), < 0); zadd(a, b, c); assert(zcmp(a, c), < 0); assert(zcmpmag(a, _2), > 0); zadd(a, c, b); assert(zcmp(a, c), < 0); assert(zcmpmag(a, _2), > 0); zadd(a, b, _1); assert(zcmp(a, _0), == 0); assert(zcmpmag(a, _0), == 0); zadd(a, _1, b); assert(zcmp(a, _0), == 0); assert(zcmpmag(a, _0), == 0); zneg(b, _1); zneg(c, _2); zsub(a, _0, b); assert(zcmp(a, _1), == 0); zsub(a, b, _0); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), < 0); zsub(a, b, c); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), == 0); zsub(a, c, b); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), < 0); zsub(a, b, _1); assert(zcmpmag(a, _2), == 0); assert(zcmp(a, _2), < 0); assert(zcmp(a, c), == 0); zsub(a, _1, b); assert(zcmp(b, _1), < 0); assert(zcmpmag(b, _1), == 0); assert(zcmp(a, _2), == 0); zsetu(a, 1000); zsetu(b, 0); assert(zcmp(a, b), != 0); n = zsave(a, buf); assert(n > 0, > 0); assert_zu(zload(b, buf), n); assert(zcmp(a, b), == 0); zneg(b, _1); zneg(c, _2); assert((zadd_unsigned(a, _1, _2), zcmp(a, _3)), == 0); assert((zadd_unsigned(a, b, c), zcmp(a, _3)), == 0); assert((zadd_unsigned(a, b, _2), zcmp(a, _3)), == 0); assert((zadd_unsigned(a, _1, c), zcmp(a, _3)), == 0); assert((zadd_unsigned(a, _0, _0), zcmp(a, _0)), == 0); assert((zadd_unsigned(a, _0, _1), zcmp(a, _1)), == 0); assert((zadd_unsigned(a, _1, _1), zcmp(a, _2)), == 0); assert((zadd_unsigned(a, _1, _0), zcmp(a, _1)), == 0); zneg(_1, _1); assert((zadd_unsigned(a, _0, _0), zcmp(a, _0)), == 0); assert((zadd_unsigned(a, _0, _1), zcmp(a, _1)), != 0); assert((zadd_unsigned(a, _0, _1), zcmpmag(a, _1)), == 0); assert((zadd_unsigned(a, _1, _1), zcmp(a, _2)), == 0); assert((zadd_unsigned(a, _1, _0), zcmp(a, _1)), != 0); assert((zadd_unsigned(a, _1, _0), zcmpmag(a, _1)), == 0); zneg(_1, _1); assert((zsub_unsigned(a, _2, _1), zcmp(a, _1)), == 0); assert((zsub_unsigned(a, _2, b), zcmp(a, _1)), == 0); assert((zsub_unsigned(a, c, _1), zcmp(a, _1)), == 0); assert((zsub_unsigned(a, c, b), zcmp(a, _1)), == 0); assert((zsub_unsigned(a, _1, _2), zcmp(a, b)), == 0); assert((zsub_unsigned(a, b, _2), zcmp(a, b)), == 0); assert((zsub_unsigned(a, _1, c), zcmp(a, b)), == 0); assert((zsub_unsigned(a, b, c), zcmp(a, b)), == 0); assert_zu(zbits(_0), 1); assert_zu(zbits(_1), 1); assert_zu(zbits(_2), 2); assert_zu(zbits(_3), 2); assert_zu(zlsb(_0), SIZE_MAX); assert_zu(zlsb(_1), 0); assert_zu(zlsb(_2), 1); assert_zu(zlsb(_3), 0); assert((zand(a, _0, _0), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zand(a, _0, _1), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zand(a, _0, _2), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zand(a, _0, _3), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zand(a, _1, _1), zcmp(a, _1)), == 0); assert((zand(a, _1, _2), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zand(a, _1, _3), zcmp(a, _1)), == 0); assert((zand(a, _2, _2), zcmp(a, _2)), == 0); assert((zand(a, _2, _3), zcmp(a, _2)), == 0); assert((zand(a, _3, _3), zcmp(a, _3)), == 0); assert((zor(a, _0, _0), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zor(a, _0, _1), zcmp(a, _1)), == 0); assert((zor(a, _0, _2), zcmp(a, _2)), == 0); assert((zor(a, _0, _3), zcmp(a, _3)), == 0); assert((zor(a, _1, _1), zcmp(a, _1)), == 0); assert((zor(a, _1, _2), zcmp(a, _3)), == 0); assert((zor(a, _1, _3), zcmp(a, _3)), == 0); assert((zor(a, _2, _2), zcmp(a, _2)), == 0); assert((zor(a, _2, _3), zcmp(a, _3)), == 0); assert((zor(a, _3, _3), zcmp(a, _3)), == 0); assert((zxor(a, _0, _0), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zxor(a, _0, _1), zcmp(a, _1)), == 0); assert((zxor(a, _0, _2), zcmp(a, _2)), == 0); assert((zxor(a, _0, _3), zcmp(a, _3)), == 0); assert((zxor(a, _1, _1), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zxor(a, _1, _2), zcmp(a, _3)), == 0); assert((zxor(a, _1, _3), zcmp(a, _2)), == 0); assert((zxor(a, _2, _2), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zxor(a, _2, _3), zcmp(a, _1)), == 0); assert((zxor(a, _3, _3), zcmp(a, _0)), == 0); assert(zzero(a), == 1); zneg(b, _1); zneg(c, _3); zneg(_1, _1); zand(a, b, c); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), == 0); zneg(_1, _1); assert((zand(a, b, _3), zcmp(a, _1)), == 0); assert((zand(a, _1, c), zcmp(a, _1)), == 0); assert((zand(a, _0, c), zcmp(a, _0)), == 0); assert((zand(a, b, _0), zcmp(a, _0)), == 0); zneg(b, _1); zneg(c, _2); zneg(_3, _3); zor(a, b, c); assert(zcmpmag(a, _3), == 0); assert(zcmp(a, _3), == 0); zor(a, b, _2); assert(zcmpmag(a, _3), == 0); assert(zcmp(a, _3), == 0); zor(a, _1, c); assert((zcmpmag(a, _3)), == 0); assert((zcmp(a, _3)), == 0); assert((zor(a, _0, c), zcmp(a, c)), == 0); assert((zor(a, b, _0), zcmp(a, b)), == 0); zneg(_3, _3); zneg(b, _1); zneg(c, _2); zxor(a, b, c); assert(zcmpmag(a, _3), == 0); assert(zcmp(a, _3), == 0); zneg(_3, _3); zxor(a, b, _2); assert(zcmpmag(a, _3), == 0); assert(zcmp(a, _3), == 0); zxor(a, _1, c); assert(zcmpmag(a, _3), == 0); assert(zcmp(a, _3), == 0); zxor(a, b, _0); assert(zcmpmag(a, b), == 0); assert(zcmp(a, b), == 0); zxor(a, _0, c); assert(zcmpmag(a, c), == 0); assert(zcmp(a, c), == 0); zneg(_3, _3); assert((zlsh(a, _0, 0), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zlsh(a, _0, 1), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zlsh(a, _1, 0), zcmp(a, _1)), == 0); assert((zlsh(a, _1, 1), zcmp(a, _2)), == 0); assert((zlsh(a, _1, 2), zcmp(a, _2)), > 0); assert((zlsh(a, _2, 0), zcmp(a, _2)), == 0); assert((zlsh(a, _2, 1), zcmp(a, _2)), > 0); zset(a, _0); assert((zlsh(a, a, 0), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zlsh(a, a, 1), zcmp(a, _0)), == 0); assert(zzero(a), == 1); zset(a, _1); assert((zlsh(a, a, 0), zcmp(a, _1)), == 0); assert((zlsh(a, a, 1), zcmp(a, _2)), == 0); assert((zlsh(a, a, 2), zcmp(a, _2)), > 0); zset(a, _2); assert((zlsh(a, a, 0), zcmp(a, _2)), == 0); assert((zlsh(a, a, 1), zcmp(a, _2)), > 0); assert((zrsh(a, _0, 0), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zrsh(a, _0, 1), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zrsh(a, _1, 0), zcmp(a, _1)), == 0); assert((zrsh(a, _1, 1), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zrsh(a, _1, 2), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zrsh(a, _2, 0), zcmp(a, _2)), == 0); assert((zrsh(a, _2, 1), zcmp(a, _1)), == 0); assert((zrsh(a, _2, 2), zcmp(a, _0)), == 0); assert(zzero(a), == 1); zset(a, _0); assert((zrsh(a, a, 0), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zrsh(a, a, 1), zcmp(a, _0)), == 0); assert(zzero(a), == 1); zset(a, _1); assert((zrsh(a, a, 0), zcmp(a, _1)), == 0); assert((zrsh(a, a, 1), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert((zrsh(a, a, 2), zcmp(a, _0)), == 0); assert(zzero(a), == 1); zset(a, _2); assert((zrsh(a, a, 0), zcmp(a, _2)), == 0); assert((zrsh(a, a, 1), zcmp(a, _1)), == 0); assert((zrsh(a, a, 2), zcmp(a, _0)), == 0); assert(zzero(a), == 1); assert(zbtest(_0, 0), == 0); assert(zbtest(_1, 0), == 1); assert(zbtest(_2, 0), == 0); assert(zbtest(_3, 0), == 1); assert(zbtest(_0, 1), == 0); assert(zbtest(_1, 1), == 0); assert(zbtest(_2, 1), == 1); assert(zbtest(_3, 1), == 1); assert(zbtest(_0, 2), == 0); assert(zbtest(_1, 2), == 0); assert(zbtest(_2, 2), == 0); assert(zbtest(_3, 2), == 0); znot(a, _2); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), != 0); znot(a, a); assert(zcmp(a, _0), == 0); zsetu(a, 0x1234); zsetu(c, 0x234); ztrunc(a, a, 12); assert(zcmp(a, c), == 0); zsetu(a, 0xEEFF); zsetu(c, 0xEE); zsetu(d, 0xFF); zsplit(a, b, a, 8); assert(zcmpmag(a, c), == 0); assert(zcmpmag(b, d), == 0); zsetu(a, 0xEEFF); zsplit(b, a, a, 8); assert(zcmpmag(b, c), == 0); assert(zcmpmag(a, d), == 0); zmul(a, _2, _3); assert(zcmpi(a, 6), == 0); zneg(_3, _3); zmul(a, _2, _3); assert(zcmpi(a, -6), == 0); zneg(_3, _3); zneg(_2, _2); zmul(a, _2, _3); assert(zcmpi(a, -6), == 0); zneg(_3, _3); zmul(a, _2, _3); assert(zcmpi(a, 6), == 0); zneg(_3, _3); zneg(_2, _2); zmul(a, _3, _3); assert(zcmpi(a, 9), == 0); zsqr(a, _3); assert(zcmpi(a, 9), == 0); zneg(_3, _3); zmul(a, _3, _3); assert(zcmpi(a, 9), == 0); zsqr(a, _3); assert(zcmpi(a, 9), == 0); zneg(_3, _3); zseti(a, 8); zseti(b, 2); zdiv(c, a, b); assert(zcmpi(c, 4), == 0); zseti(b, -2); zdiv(c, a, b); assert(zcmpi(c, -4), == 0); zseti(a, -8); zseti(b, 2); zdiv(c, a, b); assert(zcmpi(c, -4), == 0); zseti(b, -2); zdiv(c, a, b); assert(zcmpi(c, 4), == 0); zseti(a, 1000); zseti(b, 10); zdiv(c, a, b); assert(zcmpi(c, 100), == 0); zseti(b, -10); zdiv(c, a, b); assert(zcmpi(c, -100), == 0); zseti(a, -1000); zseti(b, 10); zdiv(c, a, b); assert(zcmpi(c, -100), == 0); zseti(b, -10); zdiv(c, a, b); assert(zcmpi(c, 100), == 0); zseti(a, 7); zseti(b, 3); zmod(c, a, b); assert(zcmpi(c, 1), == 0); zseti(b, -3); zmod(c, a, b); assert(zcmpi(c, 1), == 0); zseti(a, -7); zseti(b, 3); zmod(c, a, b); assert(zcmpi(c, -1), == 0); zseti(b, -3); zmod(c, a, b); assert(zcmpi(c, -1), == 0); zseti(a, 7); zseti(b, 3); zdivmod(d, c, a, b); assert(zcmpi(d, 2), == 0); assert(zcmpi(c, 1), == 0); zseti(b, -3); zdivmod(d, c, a, b); assert(zcmpi(d, -2), == 0); assert(zcmpi(c, 1), == 0); zseti(a, -7); zseti(b, 3); zdivmod(d, c, a, b); assert(zcmpi(d, -2), == 0); assert(zcmpi(c, -1), == 0); zseti(b, -3); zdivmod(d, c, a, b); assert(zcmpi(d, 2), == 0); assert(zcmpi(c, -1), == 0); zseti(a, 10); zseti(b, -1); zpow(a, a, b); assert(zcmp(a, _0), == 0); zseti(a, 10); zseti(b, -1); zseti(a, 20); zmodpow(a, a, b, c); assert(zcmp(a, _0), == 0); zseti(a, 10); zseti(c, 100000L); zpowu(a, a, 5); assert(zcmpmag(a, c), == 0); assert(zcmp(a, c), == 0); zseti(a, -10); zseti(c, -100000L); zpowu(a, a, 5); assert(zcmpmag(a, c), == 0); assert(zcmp(a, c), == 0); zseti(a, -10); zseti(c, 10000L); zpowu(a, a, 4); assert(zcmpmag(a, c), == 0); assert(zcmp(a, c), == 0); zseti(a, 10); zseti(c, 3); zmodpowu(a, a, 5, c); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), == 0); zseti(a, 10); zseti(b, 5); zseti(c, 100000L); zpow(a, a, b); assert(zcmpmag(a, c), == 0); assert(zcmp(a, c), == 0); zseti(a, -10); zseti(b, 5); zseti(c, -100000L); zpow(a, a, b); assert(zcmpmag(a, c), == 0); assert(zcmp(a, c), == 0); zseti(a, -10); zseti(b, 4); zseti(c, 10000L); zpow(a, a, b); assert(zcmpmag(a, c), == 0); assert(zcmp(a, c), == 0); zseti(a, 10); zseti(b, 5); zseti(c, 3); zmodpow(a, a, b, c); assert(zcmpmag(a, _1), == 0); assert(zcmp(a, _1), == 0); zseti(a, 102); zseti(b, 501); zseti(c, 5); zmodmul(a, a, b, c); assert(zcmp(a, _2), == 0); zseti(b, 2 * 3 * 3 * 7); zseti(c, 3 * 7 * 11); zseti(d, 3 * 7); assert((zgcd(a, _0, _0), zcmp(a, _0)), == 0); assert((zgcd(a, b, _0), zcmp(a, b)), == 0); assert((zgcd(a, _0, c), zcmp(a, c)), == 0); assert((zgcd(a, b, b), zcmp(a, b)), == 0); assert((zgcd(a, b, _2), zcmp(a, _2)), == 0); assert((zgcd(a, _2, b), zcmp(a, _2)), == 0); assert((zgcd(a, _2, _2), zcmp(a, _2)), == 0); assert((zgcd(a, c, _2), zcmp(a, _1)), == 0); assert((zgcd(a, _2, c), zcmp(a, _1)), == 0); assert((zgcd(a, b, _1), zcmp(a, _1)), == 0); assert((zgcd(a, _1, c), zcmp(a, _1)), == 0); assert((zgcd(a, _1, _1), zcmp(a, _1)), == 0); assert((zgcd(a, b, c), zcmp(a, d)), == 0); assert((zgcd(a, c, b), zcmp(a, d)), == 0); zsets(a, "1234"); assert(zcmpi(a, 1234), == 0); zsets(b, "+1234"); assert(zcmp(a, b), == 0); assert_zu(zstr_length(_0, 10), 1); assert_zu(zstr_length(_1, 10), 1); assert_zu(zstr_length(_2, 10), 1); assert_zu(zstr_length(_3, 10), 1); zneg(_2, _2); assert_zu(zstr_length(_2, 10), 2); zneg(_2, _2); assert_zu(zstr_length(a, 10), 4); zstr(a, buf, 0); assert_s(buf, "1234"); zsets(a, "-1234"); zseti(b, -1234); zseti(c, 1234); assert(zcmp(a, _0), < 0); assert(zcmp(a, b), == 0); assert(zcmpmag(a, c), == 0); assert(zcmp(a, c), < 0); zstr(a, buf, 0); assert_s(buf, "-1234"); assert_s(zstr(a, buf, 0), "-1234"); zsetu(d, 100000UL); zrand(a, FAST_RANDOM, UNIFORM, d); assert(zcmp(a, _0), >= 0); assert(zcmp(a, d), <= 0); zrand(b, SECURE_RANDOM, UNIFORM, d); assert(zcmp(b, _0), >= 0); assert(zcmp(b, d), <= 0); zrand(c, FASTEST_RANDOM, UNIFORM, d); assert(zcmp(c, _0), >= 0); assert(zcmp(c, d), <= 0); assert(zcmp(a, b), != 0); assert(zcmp(a, c), != 0); assert(zcmp(b, c), != 0); zsetu(d, 100000UL); zrand(a, DEFAULT_RANDOM, QUASIUNIFORM, d); assert(zcmp(a, _0), >= 0); assert(zcmp(a, d), <= 0); zrand(b, DEFAULT_RANDOM, QUASIUNIFORM, d); assert(zcmp(b, _0), >= 0); assert(zcmp(b, d), <= 0); zrand(c, DEFAULT_RANDOM, QUASIUNIFORM, d); assert(zcmp(c, _0), >= 0); assert(zcmp(c, d), <= 0); assert(zcmp(a, b), != 0); assert(zcmp(a, c), != 0); assert(zcmp(b, c), != 0); zsetu(d, 100000UL); zrand(a, DEFAULT_RANDOM, MODUNIFORM, d); assert(zcmp(a, _0), >= 0); assert(zcmp(a, d), <= 0); zrand(b, DEFAULT_RANDOM, MODUNIFORM, d); assert(zcmp(b, _0), >= 0); assert(zcmp(b, d), <= 0); zrand(c, DEFAULT_RANDOM, MODUNIFORM, d); assert(zcmp(c, _0), >= 0); assert(zcmp(c, d), <= 0); assert(zcmp(a, b), != 0); assert(zcmp(a, c), != 0); assert(zcmp(b, c), != 0); assert((zseti(a, -5), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, -4), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, -3), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, -2), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, -1), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, 0), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, 1), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, 2), zptest(0, a, 100)), == PRIME); assert((zseti(a, 3), zptest(0, a, 100)), == PRIME); assert((zseti(a, 4), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, 5), zptest(0, a, 100)), != NONPRIME); assert((zseti(a, 6), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, 7), zptest(0, a, 100)), != NONPRIME); assert((zseti(a, 8), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, 9), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, 10), zptest(0, a, 100)), == NONPRIME); assert((zseti(a, 11), zptest(0, a, 100)), != NONPRIME); assert((zseti(a, 101), zptest(0, a, 100)), != NONPRIME); #if defined(ZAHL_UNSAFE) (void) env2; #else assert_nr(zdivmod(a, b, _0, _0)); assert_nr(zdivmod(a, b, _1, _0)); zdivmod(a, b, _0, _1); zdivmod(a, b, _1, _1); assert_nr(zdiv(a, _0, _0)); assert_nr(zdiv(a, _1, _0)); zdiv(a, _0, _1); zdiv(a, _1, _1); assert_nr(zmod(a, _0, _0)); assert_nr(zmod(a, _1, _0)); zmod(a, _0, _1); zmod(a, _1, _1); assert_nr(zpow(a, _0, _0)); assert_nr((zneg(_1, _1), zpow(a, _0, _1))); zneg(_1, _1); zpow(a, _0, _1); zpow(a, _1, _0); zneg(_1, _1), zpow(a, _1, _0), zneg(_1, _1); assert_nr(zmodmul(a, _1, _1, _0)); assert_nr(zmodpow(a, _0, _0, _1)); assert_nr((zneg(_1, _1), zmodpow(a, _0, _1, _1))); zneg(_1, _1); zmodpow(a, _0, _1, _1); zmodpow(a, _1, _0, _1); zneg(_1, _1), zmodpow(a, _1, _0, _1), zneg(_1, _1); assert_nr(zmodpow(a, _0, _0, _0)); assert_nr((zneg(_1, _1), zmodpow(a, _0, _1, _0))); zneg(_1, _1); assert_nr(zmodpow(a, _0, _1, _0)); assert_nr(zmodpow(a, _1, _0, _0)); assert_nr((zneg(_1, _1), zmodpow(a, _1, _0, _0))); zneg(_1, _1); assert_nr(zpowu(a, _0, 0)); zpowu(a, _0, 1); zpowu(a, _1, 0); zneg(_1, _1), zpowu(a, _1, 0), zneg(_1, _1); assert_nr(zmodpowu(a, _0, 0, _1)); zmodpowu(a, _0, 1, _1); zmodpowu(a, _1, 0, _1); zneg(_1, _1), zmodpowu(a, _1, 0, _1), zneg(_1, _1); assert_nr(zmodpowu(a, _0, 0, _0)); assert_nr((zneg(_1, _1), zmodpowu(a, _0, 1, _0))); zneg(_1, _1); assert_nr(zmodpowu(a, _0, 1, _0)); assert_nr(zmodpowu(a, _1, 0, _0)); assert_nr((zneg(_1, _1), zmodpowu(a, _1, 0, _0))); zneg(_1, _1); assert_nr(zstr_length(a, 0)); assert_nr(zstr_length(a, 1)); zstr_length(a, 2); zstr_length(a, 3); #endif zsetu(a, 1LL); assert_s(zstr(a, buf, 1), "1"); zsetu(a, 10LL); assert_s(zstr(a, buf, 2), "10"); zsetu(a, 100LL); assert_s(zstr(a, buf, 3), "100"); zsetu(a, 1000LL); assert_s(zstr(a, buf, 4), "1000"); zsetu(a, 10000LL); assert_s(zstr(a, buf, BUF_N), "10000"); zsetu(a, 100000LL); assert_s(zstr(a, buf, BUF_N), "100000"); zsetu(a, 1000000LL); assert_s(zstr(a, buf, BUF_N), "1000000"); zsetu(a, 10000000LL); assert_s(zstr(a, buf, BUF_N), "10000000"); zsetu(a, 100000000LL); assert_s(zstr(a, buf, BUF_N), "100000000"); zsetu(a, 999999999LL); assert_s(zstr(a, buf, BUF_N), "999999999"); zsetu(a, 1000000000LL); assert_s(zstr(a, buf, BUF_N), "1000000000"); zsetu(a, 1000000001LL); assert_s(zstr(a, buf, BUF_N), "1000000001"); zsetu(a, 2000000000LL); assert_s(zstr(a, buf, BUF_N), "2000000000"); zsetu(a, 2050000000LL); assert_s(zstr(a, buf, BUF_N), "2050000000"); zsetu(a, 2100000000LL); assert_s(zstr(a, buf, BUF_N), "2100000000"); zsetu(a, 2140000000LL); assert_s(zstr(a, buf, BUF_N), "2140000000"); zsetu(a, 2147000000LL); assert_s(zstr(a, buf, BUF_N), "2147000000"); zsetu(a, 2147483000LL); assert_s(zstr(a, buf, BUF_N), "2147483000"); zsetu(a, 2147483640LL); assert_s(zstr(a, buf, BUF_N), "2147483640"); zsetu(a, 2147483646LL); assert_s(zstr(a, buf, BUF_N), "2147483646"); zseti(a, 2147483647LL); assert_s(zstr(a, buf, BUF_N), "2147483647"); zseti(a, -2147483647LL); assert_s(zstr(a, buf, BUF_N), "-2147483647"); zseti(a, -2147483647LL - 1LL); assert_s(zstr(a, buf, BUF_N), "-2147483648"); zsetu(a, 2147483647ULL); assert_s(zstr(a, buf, BUF_N), "2147483647"); zsetu(a, 2147483648ULL); assert_s(zstr(a, buf, BUF_N), "2147483648"); zsetu(a, 2147483649ULL); assert_s(zstr(a, buf, BUF_N), "2147483649"); zsetu(a, 3000000000ULL); assert_s(zstr(a, buf, BUF_N), "3000000000"); zsetu(a, 3100000000ULL); assert_s(zstr(a, buf, BUF_N), "3100000000"); zsetu(a, 3200000000ULL); assert_s(zstr(a, buf, BUF_N), "3200000000"); zsetu(a, 3300000000ULL); assert_s(zstr(a, buf, BUF_N), "3300000000"); zsetu(a, 3400000000ULL); assert_s(zstr(a, buf, BUF_N), "3400000000"); zsetu(a, 3500000000ULL); assert_s(zstr(a, buf, BUF_N), "3500000000"); zsetu(a, 3600000000ULL); assert_s(zstr(a, buf, BUF_N), "3600000000"); zsetu(a, 3700000000ULL); assert_s(zstr(a, buf, BUF_N), "3700000000"); zsetu(a, 3800000000ULL); assert_s(zstr(a, buf, BUF_N), "3800000000"); zsetu(a, 3900000000ULL); assert_s(zstr(a, buf, BUF_N), "3900000000"); zsetu(a, 3999999999ULL); assert_s(zstr(a, buf, BUF_N), "3999999999"); zsetu(a, 4000000000ULL); assert_s(zstr(a, buf, BUF_N), "4000000000"); zsetu(a, 4000000001ULL); assert_zu(zstr_length(a, 10), 10); assert_s(zstr(a, buf, BUF_N), "4000000001"); zsetu(a, 4000000000ULL); zsetu(b, 4000000000ULL); zadd(c, a, a); zsets(d, "8000000000"); assert(zcmp(c, d), == 0); zadd(c, a, b); assert(zcmp(c, d), == 0); zadd(c, c, a); zsets(d, "12000000000"); assert(zcmp(c, d), == 0); zsub(c, c, a); zsets(d, "8000000000"); assert(zcmp(c, d), == 0); zsub(c, c, a); zsets(d, "4000000000"); assert(zcmp(c, d), == 0); zsets(d, "8000000000"); zrsh(d, d, 1); assert(zcmp(c, d), == 0); zsets(a, "6234216714"); zsets(b, "9424614147"); zsets(d, "830476546"); zand(c, a, b); assert(zcmp(c, d), == 0); zsets(a, "234216714"); zsets(b, "9424614147"); zsets(d, "9629466379"); zor(c, a, b); assert(zcmp(c, d), == 0); zsets(a, "6234216714"); zsets(b, "9424614147"); zsets(d, "13997877769"); zxor(c, a, b); assert(zcmp(c, d), == 0); zsets(a, "34216714"); zsets(b, "9424614147"); zsets(d, "9458821129"); zxor(c, a, b); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zsets(d, "1000000000000000000"); zmul(c, a, a); assert(zcmp(c, d), == 0); zdiv(c, c, a); assert(zcmp(c, a), == 0); zsetu(a, 1000000000ULL); zsets(d, "1000000000000000000"); zsqr(c, a); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zmodpowu(c, a, 5, _3); assert(zcmpu(c, 1), == 0); zsetu(a, 1000000000ULL); zsets(d, "1"); zpowu(c, a, 0); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zsets(d, "1000000000"); zpowu(c, a, 1); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zsets(d, "1000000000000000000"); zpowu(c, a, 2); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zsets(b, "1000000000000000000"); zsets(d, "1000000000000000000000000000"); zmul(c, a, b); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zsets(d, "1000000000000000000000000000"); zmul(b, a, a); zmul(b, b, a); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zsets(d, "1000000000000000000000000000"); zpowu(c, a, 3); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zsets(d, "1000000000000000000000000000000000000"); zpowu(c, a, 4); assert(zcmp(c, d), == 0); zsetu(a, 1000000000ULL); zsets(d, "1000000000000000000000000000000000000000000000"); zpowu(c, a, 5); assert(zcmp(c, d), == 0); zsetu(a, 4294967294ULL); assert_s(zstr(a, buf, BUF_N), "4294967294"); zsetu(a, 4294967295ULL); assert_s(zstr(a, buf, BUF_N), "4294967295"); zsetu(a, 4294967296ULL); assert_s(zstr(a, buf, BUF_N), "4294967296"); zsetu(a, 4294967297ULL); assert_s(zstr(a, buf, BUF_N), "4294967297"); zseti(a, 9223372036854775807LL); assert_s(zstr(a, buf, BUF_N), "9223372036854775807"); zseti(a, -9223372036854775807LL); assert_s(zstr(a, buf, BUF_N), "-9223372036854775807"); zseti(a, -9223372036854775807LL - 1LL); assert_s(zstr(a, buf, BUF_N), "-9223372036854775808"); zsetu(a, 18446744073709551614ULL); assert_s(zstr(a, buf, BUF_N), "18446744073709551614"); zsetu(a, 18446744073709551615ULL); assert_s(zstr(a, buf, BUF_N), "18446744073709551615"); zadd(a, a, _1); assert_s(zstr(a, buf, BUF_N), "18446744073709551616"); zadd(a, a, _1); assert_s(zstr(a, buf, BUF_N), "18446744073709551617"); zsets(a, "1000000000000000000000000000000"); assert_s(zstr(a, buf, BUF_N), "1000000000000000000000000000000"); zsets(a, "+1000000000000000000000000000000"); assert_s(zstr(a, buf, BUF_N), "1000000000000000000000000000000"); zsets(a, "-1000000000000000000000000000000"); assert_s(zstr(a, buf, BUF_N), "-1000000000000000000000000000000"); zsetu(a, 1000000000000000ULL); zsqr(a, a); assert_s(zstr(a, buf, BUF_N), "1000000000000000000000000000000"); #include "test-random.c" done: zfree(a), zfree(b), zfree(c), zfree(d), zfree(_0), zfree(_1), zfree(_2), zfree(_3); zunsetup(); return ret; }
/* 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; }
void zbinary_ext_gcd(verylong zx, verylong zy, verylong *za, verylong *zb, verylong *zv) /* returns a * x + b * y = v, v = gcd(x, y) */ { verylong zA = 0, zB = 0, zC = 0, zD = 0; verylong zX = 0, zY = 0, zc = 0, zg = 0; verylong zu = 0; zone(&zg); zcopy(zx, &zX); zcopy(zy, &zY); while (!zodd(zX) && !zodd(zY)) { zrshift(zX, 1l, &zc); zcopy(zc, &zX); zrshift(zY, 1l, &zc); zcopy(zc, &zY); zlshift(zg, 1l, &zc); zcopy(zc, &zg); } zcopy(zX, &zu); zcopy(zY, zv); zone(&zA); zzero(&zB); zzero(&zC); zone(&zD); do { while (!zodd(zu)) { zrshift(zu, 1l, &zc); zcopy(zc, &zu); if (!zodd(zA) && !zodd(zB)) { zrshift(zA, 1l, &zc); zcopy(zc, &zA); zrshift(zB, 1l, &zc); zcopy(zc, &zB); } else { zadd(zA, zY, &zc); zrshift(zc, 1l, &zA); zsub(zB, zX, &zc); zrshift(zc, 1l, &zB); } } while (!zodd(*zv)) { zrshift(*zv, 1l, &zc); zcopy(zc, zv); if (!zodd(zC) && !zodd(zD)) { zrshift(zC, 1l, &zc); zcopy(zc, &zC); zrshift(zD, 1l, &zc); zcopy(zc, &zD); } else { zadd(zC, zY, &zc); zrshift(zc, 1l, &zC); zsub(zD, zX, &zc); zrshift(zc, 1l, &zD); } } if (zcompare(zu, *zv) >= 0) { zsub(zu, *zv, &zc); zcopy(zc, &zu); zsub(zA, zC, &zc); zcopy(zc, &zA); zsub(zB, zD, &zc); zcopy(zc, &zB); } else { zsub(*zv, zu, &zc); zcopy(zc, zv); zsub(zC, zA, &zc); zcopy(zc, &zC); zsub(zD, zB, &zc); zcopy(zc, &zD); } #ifdef DEBUG zwrite(zu); printf(" "); zwrite(*zv); printf(" "); zwrite(zA); printf(" "); zwrite(zB); printf(" "); zwrite(zC); printf(" "); zwriteln(zD); #endif } while (zscompare(zu, 0l) != 0); zcopy(zC, za); zcopy(zD, zb); zmul(zg, *zv, &zc); zcopy(zc, zv); zfree(&zA); zfree(&zB); zfree(&zC); zfree(&zD); zfree(&zX); zfree(&zY); zfree(&zc); zfree(&zg); zfree(&zu); }
int simultaneous_diophantine(double delta, long n, verylong zQ, verylong *zP, verylong *zp, verylong *zq) { double P, Q, l; int equal, found; long i, j, n1 = n + 1; verylong zd = 0, zl = 0, zr = 0, zs = 0, zt = 0; verylong **zA = allocate_very_matrix(1, n1, 1, n1); verylong **zh = allocate_very_matrix(1, n1, 1, n1); Q = zdoub(zQ); zintoz(pow(Q, delta), &zl); l = 1.0 / zdoub(zl); zmul(zl, zQ, &zd); for (i = 1; i <= n; i++) zcopy(zd, &zA[i][i]); znegate(&zl); for (i = 1; i <= n; i++) zmul(zl, zq[i], &zA[n1][i]); zone(&zA[n1][n1]); int_LLL(n1, zA, zh); found = 0; for (j = 1; !found && j <= n1; j++) { zcopy(zA[j][n1], zP); if (zcompare(*zP, zQ) != 0) { for (i = 1; i <= n; i++) { zdiv(zA[j][i], zl, &zr, &zs); zmul(*zP, zq[i], &zt); zadd(zr, zt, &zs); zdiv(zs, zQ, &zp[i], &zr); } P = zdoub(*zP); #ifdef DEBUG if (n <= 16) { printf("p = "); zwrite(*zP); printf(" p[i] "); for (i = 1; i <= n; i++) { zwrite(zp[i]); printf(" "); } printf("\n"); } #endif if (zcompare(*zP, 0) != 0) { equal = 1; for (i = 1; equal && i <= n; i++) equal = fabs(P * zdoub(zq[i]) / Q - zdoub(zp[i])) <= l; } else equal = 0; found = equal; } } free_very_matrix(zA, 1, n1, 1, n1); free_very_matrix(zh, 1, n1, 1, n1); zfree(&zd); zfree(&zl); zfree(&zr); zfree(&zs); zfree(&zt); return found; }
int DenseMtx_mmm( char *A_opt, char *B_opt, double *beta, DenseMtx *mtxC, double *alpha, DenseMtx *mtxA, DenseMtx *mtxB ) { int nrowA, ncolA, rowincA, colincA; int nrowB, ncolB, rowincB, colincB; int nrowC, ncolC, rowincC, colincC; int ierr, i, k, j, l; double *Ai, *Bj, *Ci, r_alpha, r_beta, r_temp, im_temp, im_alpha, im_beta; double one[2]={1.0, 0.0}, zero[2]={0.0, 0.0}, aconj[2], bconj[2] ; double temp[2]={0.0, 0.0}, result[2]={1.0, 0.0} ; if ( beta == NULL || alpha == NULL || mtxC == NULL || mtxA == NULL || mtxB == NULL ){ fprintf(stderr, "\n fatal error in Input" "\n one or more of beta, alpha, mtxC, mtxB and" " mtxA is NULL\n") ; return(-1) ; } if ( (DENSEMTX_IS_REAL(mtxA) != DENSEMTX_IS_REAL(mtxB)) || (DENSEMTX_IS_REAL(mtxA) != DENSEMTX_IS_REAL(mtxC)) ){ fprintf(stderr,"mtxA, mtxB and mtxC do not have the same data type\n"); return(-2); } DenseMtx_dimensions(mtxA, &nrowA, &ncolA); DenseMtx_dimensions(mtxB, &nrowB, &ncolB); DenseMtx_dimensions(mtxC, &nrowC, &ncolC); rowincA=DenseMtx_rowIncrement(mtxA); colincA=DenseMtx_columnIncrement(mtxA); rowincB=DenseMtx_rowIncrement(mtxB); colincB=DenseMtx_columnIncrement(mtxB); rowincC=DenseMtx_rowIncrement(mtxC); colincC=DenseMtx_columnIncrement(mtxC); r_alpha=*alpha; r_beta =*beta; r_temp =*temp; if ( B_opt[0] == 'N' || B_opt[0] == 'n' ){ if (A_opt[0] == 'N' || A_opt[0] == 'n'){/*Form C := beta*c+alpha*A*B*/ if (ncolA != nrowB || nrowC != nrowA || ncolC != ncolB) { fprintf(stderr,"Error in Input DenseMtx_mmm\n"); return(-3); } } else if ( (A_opt[0] == 'T' || A_opt[0] == 't') || (A_opt[0] == 'C' || A_opt[0] == 'c') ){ if (nrowA != nrowB || nrowC != ncolA || ncolC != ncolB) { fprintf(stderr,"Error in Input DenseMtx_mmm\n"); exit(-3); } } else { fprintf(stderr,"Invalid option for mtxA\n"); return(-4); } } else if ( (B_opt[0] == 'T' || B_opt[0] == 't') || (B_opt[0] == 'C' || B_opt[0] == 'c') ){ if (A_opt[0] == 'N' || A_opt[0] == 'n'){ if (ncolA != ncolB || nrowC != nrowA || ncolC != nrowB) { fprintf(stderr,"Error in Input DenseMtx_mmm\n"); return(-3); } } else if ( (A_opt[0] == 'T' || A_opt[0] == 't') || (A_opt[0] == 'C' || A_opt[0] == 'c') ){ if (nrowA != ncolB || nrowC != ncolA || ncolC != nrowB) { fprintf(stderr,"Error in Input DenseMtx_mmm\n"); return(-3); } } else { fprintf(stderr,"Invalid option for mtxA\n"); return(-4); } } else { fprintf(stderr,"Invalid option for mtxB\n"); return(-4); } if (DENSEMTX_IS_REAL(mtxA)) { if ( r_alpha == *zero ) { if( r_beta == *zero ) { DenseMtx_zero (mtxC); } else { DenseMtx_scale(mtxC,&r_beta); } return(1); } if ( B_opt[0] == 'N' || B_opt[0] == 'n' ){ if (A_opt[0] == 'N' || A_opt[0] == 'n'){/*Form C := beta*c+alpha*A*B*/ for (i=0; i<nrowA; i++){ ierr=DenseMtx_row(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<ncolB; j++){ ierr=DenseMtx_column(mtxB, j, &Bj); r_temp = 0.0; for (k=0; k<ncolA; k++){ r_temp += Ai[k*colincA]*Bj[k*rowincB]; } if( r_beta == *zero ){ Ci[j*colincC] = r_alpha*r_temp; } else { Ci[j*colincC] = r_alpha*r_temp + r_beta*Ci[j*colincC]; } } } } else {/* Form C := alpha*AT*B + beta*C. */ for (i=0; i<ncolA; i++){ ierr=DenseMtx_column(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<ncolB; j++){ ierr=DenseMtx_column(mtxB, j, &Bj); r_temp = 0.0; for (k=0; k<nrowA; k++){ r_temp += Ai[k*rowincA]*Bj[k*rowincB]; } if( r_beta == *zero ){ Ci[j*colincC] = r_alpha*r_temp; } else { Ci[j*colincC] = r_alpha*r_temp + r_beta*Ci[j*colincC]; } } } } } else { if (A_opt[0] == 'N' || A_opt[0] == 'n'){/*Form C := alpha*A*B'+beta*C */ for (i=0; i<nrowA; i++){ ierr=DenseMtx_row(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<nrowB; j++){ ierr=DenseMtx_row(mtxB, j, &Bj); r_temp = 0.0; for (k=0; k<ncolA; k++){ r_temp += Ai[k*colincA]*Bj[k*colincB]; } if( r_beta == *zero ){ Ci[j*colincC] = r_alpha*r_temp; } else { Ci[j*colincC] = r_alpha*r_temp + r_beta*Ci[j*colincC]; } } } } else { /* Form C := alpha*A'*B' + beta*C */ for (i=0; i<ncolA; i++){ ierr=DenseMtx_column(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<nrowB; j++){ ierr=DenseMtx_row(mtxB, j, &Bj); r_temp = 0.0; for (k=0; k<nrowA; k++){ r_temp += Ai[k*rowincA]*Bj[k*colincB]; } if( r_beta == *zero ){ Ci[j*colincC] = r_alpha*r_temp; } else { Ci[j*colincC] = r_alpha*r_temp + r_beta*Ci[j*colincC]; } } } } } } else { /* complex case */ rowincA *= 2; rowincB *= 2; rowincC *= 2; colincA *= 2; colincB *= 2; colincC *= 2; im_alpha=*(alpha+1); im_beta =*(beta+1); im_temp =*(temp+1); if ( r_alpha == *zero && im_alpha == *zero ) { if( r_beta == *zero && im_beta == *zero ) { DenseMtx_zero (mtxC); } else { DenseMtx_scale(mtxC,beta); } return(1); } if ( B_opt[0] == 'N' || B_opt[0] == 'n' ){ if (A_opt[0] == 'N' || A_opt[0] == 'n'){/*Form C := beta*c+alpha*A*B*/ for (i=0; i<nrowA; i++){ ierr=DenseMtx_row(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<ncolB; j++){ temp[0] = 0.0; temp[1] = 0.0; ierr=DenseMtx_column(mtxB, j, &Bj); for (k=0; k<ncolA; k++){ zmul(&Ai[k*colincA],&Bj[k*rowincB],result); zadd(temp,result,temp); } if( r_beta == *zero && im_beta == *zero ){ zmul(alpha,temp,&Ci[j*colincC]); } else { zmul(beta,&Ci[j*colincC],&Ci[j*colincC]); zmul(alpha,temp,temp); zadd(temp,&Ci[j*colincC],&Ci[j*colincC]); } } } } else {/* Form C := alpha*AT*B + beta*C. */ for (i=0; i<ncolA; i++){ ierr=DenseMtx_column(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<ncolB; j++){ ierr=DenseMtx_column(mtxB, j, &Bj); temp[0] = 0.0; temp[1] = 0.0; for (k=0; k<nrowA; k++){ if (A_opt[0] == 'C' || A_opt[0] == 'c'){ /* Form C := alpha*conjg( A')*B + beta*C. */ aconj[0] = Ai[k*rowincA]; aconj[1] = -Ai[k*rowincA+1]; zmul(aconj,&Bj[k*rowincB],result); } else { zmul(&Ai[k*rowincA],&Bj[k*rowincB],result); } zadd(temp,result,temp); } if( r_beta == *zero ){ zmul(alpha,temp,&Ci[j*colincC]); } else { zmul(alpha,temp,temp); zmul(beta,&Ci[j*colincC],&Ci[j*colincC]); zadd(temp,&Ci[j*colincC],&Ci[j*colincC]); } } } } } else if ( B_opt[0] == 'T' || B_opt[0] == 'T' ){ if (A_opt[0] == 'N' || A_opt[0] == 'n'){/*Form C := alpha*A*B'+beta*C */ for (i=0; i<nrowA; i++){ ierr=DenseMtx_row(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<nrowB; j++){ ierr=DenseMtx_row(mtxB, j, &Bj); temp[0] = 0.0; temp[1] = 0.0; for (k=0; k<ncolA; k++){ zmul(&Ai[k*colincA],&Bj[k*colincB],result); zadd(temp,result,temp); } if( r_beta == *zero ){ zmul(alpha,temp,&Ci[j*colincC]); } else { zmul(alpha,temp,temp); zmul(beta,&Ci[j*colincC],&Ci[j*colincC]); zadd(temp,&Ci[j*colincC],&Ci[j*colincC]); } } } } else { /* Form C := alpha*A'*B' + beta*C */ for (i=0; i<ncolA; i++){ ierr=DenseMtx_column(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<nrowB; j++){ ierr=DenseMtx_row(mtxB, j, &Bj); temp[0] = 0.0; temp[1] = 0.0; for (k=0; k<nrowA; k++){ if (A_opt[0] == 'C' || A_opt[0] == 'c'){ /* Form C := alpha*conjg( A')*B' + beta*C. */ aconj[0] = Ai[k*rowincA]; aconj[1] = (-1)*Ai[k*rowincA+1]; zmul(aconj,&Bj[k*rowincB],result); } else { zmul(&Ai[k*rowincA],&Bj[k*rowincB],result); } zadd(temp,result,temp); } if( r_beta == *zero ){ zmul(alpha,temp,&Ci[j*colincC]); } else { zmul(alpha,temp,temp); zmul(beta,&Ci[j*colincC],&Ci[j*colincC]); zadd(temp,&Ci[j*colincC],&Ci[j*colincC]); } } } } } else { if (A_opt[0] == 'N' || A_opt[0] == 'n'){ /*Form C := alpha*A*conjg(B')+beta*C */ for (i=0; i<nrowA; i++){ ierr=DenseMtx_row(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<nrowB; j++){ ierr=DenseMtx_row(mtxB, j, &Bj); temp[0] = 0.0; temp[1] = 0.0; for (k=0; k<ncolA; k++){ bconj[0] = Bj[k*colincB]; bconj[1] = -Bj[k*colincB+1]; zmul(&Ai[k*colincA],bconj,result); zadd(temp,result,temp); } if( r_beta == *zero ){ zmul(alpha,temp,&Ci[j*colincC]); } else { zmul(alpha,temp,temp); zmul(beta,&Ci[j*colincC],&Ci[j*colincC]); zadd(temp,&Ci[j*colincC],&Ci[j*colincC]); } } } } else { /* Form C := alpha*A'*conjg(B') + beta*C */ for (i=0; i<ncolA; i++){ ierr=DenseMtx_column(mtxA, i, &Ai); ierr=DenseMtx_row(mtxC, i, &Ci); for (j=0; j<nrowB; j++){ ierr=DenseMtx_row(mtxB, j, &Bj); temp[0] = 0.0; temp[1] = 0.0; for (k=0; k<nrowA; k++){ bconj[0] = Bj[k*colincB]; bconj[1] = -Bj[k*colincB+1]; if (A_opt[0] == 'C' || A_opt[0] == 'c'){ /* Form C := alpha*conjg( A')*conjg(B') + beta*C. */ aconj[0] = Ai[k*rowincA]; aconj[1] = -Ai[k*rowincA+1]; zmul(aconj,bconj,result); } else { zmul(&Ai[k*rowincA],bconj,result); } zadd(temp,result,temp); } if( r_beta == *zero ){ zmul(alpha,temp,&Ci[j*colincC]); } else { zmul(alpha,temp,temp); zmul(beta,&Ci[j*colincC],&Ci[j*colincC]); zadd(temp,&Ci[j*colincC],&Ci[j*colincC]); } } } } } } return(1); }