{$ifopt c-}
{$error 'Must enable assertions'}
{$endif}
const
BASE10 = 10;
BASE16 = 16;
Z_FMT = '%Zd';
Q_FMT = '%Qd';
function alloc_func(alloc_size: sizeuint): pointer; cdecl;
begin
result := getmem(alloc_size);
end;
procedure free_proc(p: pointer; size: sizeuint); cdecl;
begin
assert(size = size); // hint off
freemem(p);
end;
function reallocate_func(p: pointer; old_size, new_size: sizeuint): pointer; cdecl;
begin
assert(old_size = old_size); // hint off
result := reallocmem(p, new_size);
end;
function rnd_test(var state: randstate_t): boolean;
const N = 1000000;
var r1, r2, r3: valuint;
begin
r1 := mp_urandomm_ui(state, N);
r2 := mp_urandomm_ui(state, N);
r3 := mp_urandomm_ui(state, N);
result := (r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3));
end;
{ TTestGmpBinding }
procedure TTestGmpBinding.mp_set_memory_functions_test;
var
af0, af: alloc_func_t;
rf0, rf: reallocate_func_t;
fp0, fp: free_proc_t;
begin
mp_get_memory_functions(@af0, @rf0, @fp0);
try
mp_set_memory_functions(@alloc_func, @reallocate_func, @free_proc);
mp_get_memory_functions(@af, @rf, @fp);
assert(af = @alloc_func);
assert(rf = @reallocate_func);
assert(fp = @free_proc);
finally
mp_set_memory_functions(af0, rf0, fp0);
mp_get_memory_functions(@af, @rf, @fp);
assert(af = af0);
assert(rf = rf0);
assert(fp = fp0);
end;
end;
procedure TTestGmpBinding.mp_get_memory_functions_test;
var
af: alloc_func_t;
fp: free_proc_t;
rf: reallocate_func_t;
begin
af := nil;
fp := nil;
rf := nil;
mp_get_memory_functions(nil, nil, nil);
assert(af = nil);
assert(fp = nil);
assert(rf = nil);
mp_get_memory_functions(@af, nil, nil);
assert(af <> nil);
assert(fp = nil);
assert(rf = nil);
af := nil;
mp_get_memory_functions(nil, @rf, nil);
assert(af = nil);
assert(fp = nil);
assert(rf <> nil);
rf := nil;
mp_get_memory_functions(nil, nil, @fp);
assert(af = nil);
assert(fp <> nil);
assert(rf = nil);
end;
procedure TTestGmpBinding.mp_randinit_default_test;
var state: randstate_t;
begin
mp_randinit_default(state);
assert(rnd_test(state));
mp_randclear(state);
end;
procedure TTestGmpBinding.mp_randinit_mt_test;
var state: randstate_t;
begin
mp_randinit_mt(state);
assert(rnd_test(state));
mp_randclear(state);
end;
procedure TTestGmpBinding.mp_randinit_lc_2exp_test;
const
A_ = 3;
C = 5;
M2EXP = 8;
var
state: randstate_t;
a: mpz_t;
begin
mpz_init_set_ui(a, A_);
mp_randinit_lc_2exp(state, a, C, M2EXP);
assert(rnd_test(state));
mp_randclear(state);
mpz_clear(a);
end;
procedure TTestGmpBinding.mp_randinit_lc_2exp_size_test;
var state: randstate_t;
begin
assert(longbool(mp_randinit_lc_2exp_size(state, 0)));
assert(rnd_test(state));
mp_randclear(state);
end;
procedure TTestGmpBinding.mp_randinit_set_test;
var rop, op: randstate_t;
begin
mp_randinit_default(op);
mp_randinit_set(rop, op);
assert(rnd_test(rop));
mp_randclear(rop);
mp_randclear(op);
end;
procedure TTestGmpBinding.mp_randclear_test;
var state: randstate_t;
begin
mp_randinit_default(state);
mp_randclear(state);
end;
procedure TTestGmpBinding.mp_randseed_test;
var
state: randstate_t;
seed: mpz_t;
begin
mp_randinit_default(state);
mpz_init_set_ui(seed, 0);
mp_randseed(state, seed);
mp_randclear(state);
mpz_clear(seed);
end;
procedure TTestGmpBinding.mp_randseed_ui_test;
var state: randstate_t;
begin
mp_randinit_default(state);
mp_randseed_ui(state, 0);
mp_randclear(state);
end;
procedure TTestGmpBinding.mp_urandomb_ui_test;
const
B = 8 * (sizeof(valuint) - 1);
N = 1 shl B;
var
state: randstate_t;
r1, r2, r3: valuint;
begin
mp_randinit_default(state);
r1 := mp_urandomb_ui(state, B);
r2 := mp_urandomb_ui(state, B);
r3 := mp_urandomb_ui(state, B);
assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
mp_randclear(state);
end;
procedure TTestGmpBinding.mp_urandomm_ui_test;
const N = high(valuint);
var
state: randstate_t;
r1, r2, r3: valuint;
begin
mp_randinit_default(state);
r1 := mp_urandomm_ui(state, N);
r2 := mp_urandomm_ui(state, N);
r3 := mp_urandomm_ui(state, N);
assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
mp_randclear(state);
end;
procedure TTestGmpBinding.mp_asprintf_test;
const
N = 123456;
S = '123456';
var
z: mpz_t;
p: pchar;
begin
mpz_init_set_ui(z, N);
assert(mp_asprintf(p, Z_FMT, [@z]) = length(S));
assert(p = S);
freemem(p);
mpz_clear(z);
end;
procedure TTestGmpBinding.mp_asprintf_test2;
const
N = 123456;
S = '123456';
var
z: mpz_t;
p: pchar;
begin
mpz_init_set_ui(z, N);
assert(mp_asprintf(p, Z_FMT, @z) = length(S));
assert(p = S);
freemem(p);
mpz_clear(z);
end;
procedure TTestGmpBinding.mp_snprintf_test;
const
N = 123456;
S = '123456';
var
z: mpz_t;
buf: pchar;
begin
mpz_init_set_ui(z, N);
getmem(buf, length(S) + 1);
assert(mp_snprintf(buf, length(S) + 1, Z_FMT, [@z]) = length(S));
assert(buf = S);
freemem(buf);
mpz_clear(z);
end;
procedure TTestGmpBinding.mp_snprintf_test2;
const
N = 123456;
S = '123456';
var
z: mpz_t;
buf: pchar;
begin
mpz_init_set_ui(z, N);
getmem(buf, length(S) + 1);
assert(mp_snprintf(buf, length(S) + 1, Z_FMT, @z) = length(S));
assert(buf = S);
freemem(buf);
mpz_clear(z);
end;
procedure TTestGmpBinding.mp_sprintf_test;
const
N = 123456;
S = '123456';
var
z: mpz_t;
buf: pchar;
begin
mpz_init_set_ui(z, N);
getmem(buf, length(S) + 1);
assert(mp_sprintf(buf, Z_FMT, [@z]) = length(S));
assert(buf = S);
freemem(buf);
mpz_clear(z);
end;
procedure TTestGmpBinding.mp_sprintf_test2;
const
N = 123456;
S = '123456';
var
z: mpz_t;
buf: pchar;
begin
mpz_init_set_ui(z, N);
getmem(buf, length(S) + 1);
assert(mp_sprintf(buf, Z_FMT, @z) = length(S));
assert(buf = S);
freemem(buf);
mpz_clear(z);
end;
procedure TTestGmpBinding.mp_sscanf_test;
const
N = 3;
D = 2;
var q: mpq_t;
begin
mpq_init(q);
assert(mp_sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, [@q]) = 1);
assert(mpq_cmp_ui(q, N, D) = 0);
mpq_clear(q);
end;
procedure TTestGmpBinding.mp_sscanf_test2;
const
N = 3;
D = 2;
var q: mpq_t;
begin
mpq_init(q);
assert(mp_sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, @q) = 1);
assert(mpq_cmp_ui(q, N, D) = 0);
mpq_clear(q);
end;
procedure TTestGmpBinding.mpz_init_test;
var integer_: mpz_t;
begin
mpz_init(integer_);
assert(mpz_get_si(integer_) = 0);
mpz_clear(integer_);
end;
procedure TTestGmpBinding.mpz_clear_test;
const N = 1000000;
var integer_: mpz_t;
begin
mpz_init2(integer_, N);
assert(mpz_get_si(integer_) = 0);
mpz_clear(integer_);
end;
procedure TTestGmpBinding.mpz_init2_test;
const N = 1000000;
var integer_: mpz_t;
begin
mpz_init2(integer_, N);
assert(mpz_get_si(integer_) = 0);
mpz_clear(integer_);
end;
procedure TTestGmpBinding.mpz_init_set_si_test;
const N = -1000000;
var rop: mpz_t;
begin
mpz_init_set_si(rop, N);
assert(mpz_get_si(rop) = N);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_init_set_ui_test;
const N = 1000000;
var rop: mpz_t;
begin
mpz_init_set_ui(rop, N);
assert(mpz_get_ui(rop) = N);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_init_set_d_test;
const N = -1000000;
var rop: mpz_t;
begin
mpz_init_set_d(rop, N);
assert(mpz_get_si(rop) = N);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_init_set_test;
const N = -1000000;
var rop, op: mpz_t;
begin
mpz_init_set_si(op, N);
mpz_init_set(rop, op);
assert(mpz_get_si(rop) = N);
mpz_clear(rop);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_init_set_str_test;
const N = 1000000;
var rop: mpz_t;
begin
assert(mpz_init_set_str(rop, pchar(inttostr(N)), BASE10) = 0);
assert(mpz_get_si(rop) = N);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_realloc_test;
const N = 1000;
var integer_: mpz_t;
begin
mpz_init(integer_);
mpz_realloc(integer_, N);
mpz_clear(integer_)
end;
procedure TTestGmpBinding.mpz_realloc2_test;
const N = 1000;
var integer_: mpz_t;
begin
mpz_init(integer_);
mpz_realloc2(integer_, N);
mpz_clear(integer_)
end;
procedure TTestGmpBinding.mpz_getlimbn_test;
const N = 1234;
var op: mpz_t;
begin
mpz_init_set_ui(op, N);
assert(mpz_getlimbn(op, 0) = N);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_export_test;
type t = word;
const
N = 1000000;
BUF_HIGH = sizeof(N) div sizeof(t);
var
export_op, import_op: mpz_t;
buf: array[0..BUF_HIGH] of t;
count: sizeuint;
begin
mpz_init_set_si(export_op, N);
mpz_init(import_op);
mpz_export(buf, count, -1, sizeof(t), 0, 0, export_op);
mpz_import(import_op, count, -1, sizeof(t), 0, 0, buf);
assert(mpz_get_si(export_op) =mpz_get_si(import_op));
mpz_clear(export_op);
mpz_clear(import_op);
end;
procedure TTestGmpBinding.mpz_import_test;
type t = word;
const
N = 1000000;
BUF_HIGH = sizeof(N) div sizeof(t);
var
export_op, import_op: mpz_t;
buf: array[0..BUF_HIGH] of t;
count: sizeuint;
begin
mpz_init_set_si(export_op, N);
mpz_init(import_op);
mpz_export(buf, count, -1, sizeof(t), 0, 0, export_op);
mpz_import(import_op, count, -1, sizeof(t), 0, 0, buf);
assert(mpz_get_si(export_op) =mpz_get_si(import_op));
mpz_clear(export_op);
mpz_clear(import_op);
end;
procedure TTestGmpBinding.mpz_swap_test;
const
ROP_1 = -1000;
ROP_2 = 1000000;
var rop1, rop2: mpz_t;
begin
mpz_init_set_si(rop1, ROP_1);
mpz_init_set_si(rop2, ROP_2);
mpz_swap(rop1, rop2);
assert(mpz_get_si(rop1) = ROP_2);
assert(mpz_get_si(rop2) = ROP_1);
mpz_clear(rop1);
mpz_clear(rop2);
end;
procedure TTestGmpBinding.mpz_set_test;
const OP_ = 1000000;
var rop, op: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op, OP_);
mpz_set(rop, op);
assert(mpz_get_si(rop) = OP_);
mpz_clear(rop);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_set_d_test;
const OP_ = 1000000;
var rop: mpz_t;
begin
mpz_init(rop);
mpz_set_d(rop, OP_);
assert(mpz_get_si(rop) = OP_);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_set_f_test;
const OP_ = -10;
var
op: mpf_t;
rop: mpz_t;
begin
mpf_init_set_si(op, OP_);
mpz_init(rop);
mpz_set_f(rop, op);
assert(mpz_get_si(rop) = OP_);
mpz_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpz_set_q_test;
const OP_ = -10;
var
op: mpq_t;
rop: mpz_t;
begin
mpq_init(op);
mpz_init(rop);
mpq_set_si(op, OP_, 1);
mpz_set_q(rop, op);
assert(mpz_get_si(rop) = OP_);
mpz_clear(rop);
mpq_clear(op);
end;
procedure TTestGmpBinding.mpz_set_si_test;
const OP_ = -1000000;
var rop: mpz_t;
begin
mpz_init(rop);
mpz_set_si(rop, OP_);
assert(mpz_get_si(rop) = OP_);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_set_str_test;
const OP_ = -1000000;
var rop: mpz_t;
begin
mpz_init(rop);
assert(mpz_set_str(rop, pchar(inttostr(OP_)), BASE10) = 0);
assert(mpz_get_si(rop) = OP_);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_set_ui_test;
const OP_ = 1000000;
var rop: mpz_t;
begin
mpz_init(rop);
mpz_set_ui(rop, OP_);
assert(mpz_get_si(rop) = OP_);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_get_d_test;
const N = -1000;
var op: mpz_t;
begin
mpz_init_set_si(op, N);
assert(mpz_get_d(op) = N);
mpz_clear(op)
end;
procedure TTestGmpBinding.mpz_get_d_2exp_test;
const
N_LG2 = 4;
N = 1 shl N_LG2;
var
op: mpz_t;
exp: mp_exp_t;
begin
mpz_init_set_si(op, N);
assert(mpz_get_d_2exp(exp, op) = 1 / 2);
assert(exp = N_LG2 + 1);
mpz_clear(op)
end;
procedure TTestGmpBinding.mpz_get_si_test;
const N = -1000000;
var op: mpz_t;
begin
mpz_init_set_si(op, N);
assert(mpz_get_si(op) = N);
mpz_clear(op)
end;
procedure TTestGmpBinding.mpz_get_str_test;
const N = -1000000;
var
op: mpz_t;
p: pchar;
s0, s1: string;
begin
mpz_init_set_si(op, N);
s0 := inttostr(N);
p :=mpz_get_str(nil, BASE10, op);
assert(s0 = p);
freemem(p);
setlength(s1, length(s0));
assert(pointer(mpz_get_str(pchar(s1), BASE10, op)) = pointer(s1));
assert(s0 = s1);
mpz_clear(op)
end;
procedure TTestGmpBinding.mpz_get_ui_test;
const N = 1000000;
var op: mpz_t;
begin
mpz_init_set_ui(op, N);
assert(mpz_get_ui(op) = N);
mpz_clear(op)
end;
procedure TTestGmpBinding.mpz_add_test;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_add(rop, op1, op2);
assert(mpz_get_si(rop) = OP_1 + OP_2);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_add_ui_test;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_add_ui(rop, op1, OP_2);
assert(mpz_get_si(rop) = OP_1 + OP_2);
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_sub_test;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_sub(rop, op1, op2);
assert(mpz_get_si(rop) = OP_1 - OP_2);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_sub_ui_test;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_sub_ui(rop, op1, OP_2);
assert(mpz_get_si(rop) = OP_1 - OP_2);
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_ui_sub_test;
const
OP_1 = 1000;
OP_2 = 1000000;
var rop, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op2, OP_2);
mpz_ui_sub(rop, OP_1, op2);
assert(mpz_get_si(rop) = OP_1 - OP_2);
mpz_clear(rop);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_mul_test;
const
OP_1 = -10;
OP_2 = 1000;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_mul(rop, op1, op2);
assert(mpz_get_si(rop) = OP_1 * OP_2);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_mul_si_test;
const
OP_1 = 10;
OP_2 = -1000;
var rop, op1: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_mul_si(rop, op1, OP_2);
assert(mpz_get_si(rop) = OP_1 * OP_2);
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_mul_ui_test;
const
OP_1 = -10;
OP_2 = 1000;
var rop, op1: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_mul_ui(rop, op1, OP_2);
assert(mpz_get_si(rop) = OP_1 * OP_2);
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_addmul_test;
const
ROP_ = 10;
OP_1 = -100;
OP_2 = 1000;
var rop, op1, op2: mpz_t;
begin
mpz_init_set_si(rop, ROP_);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_addmul(rop, op1, op2);
assert(mpz_get_si(rop) = ROP_ + OP_1 * OP_2);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_addmul_ui_test;
const
ROP_ = 10;
OP_1 = -100;
OP_2 = 1000;
var rop, op1: mpz_t;
begin
mpz_init_set_si(rop, ROP_);
mpz_init_set_si(op1, OP_1);
mpz_addmul_ui(rop, op1, OP_2);
assert(mpz_get_si(rop) = ROP_ + OP_1 * OP_2);
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_submul_test;
const
ROP_ = 10;
OP_1 = -100;
OP_2 = 1000;
var rop, op1, op2: mpz_t;
begin
mpz_init_set_si(rop, ROP_);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_submul(rop, op1, op2);
assert(mpz_get_si(rop) = ROP_ - OP_1 * OP_2);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_submul_ui_test;
const
ROP_ = 10;
OP_1 = -100;
OP_2 = 1000;
var rop, op1: mpz_t;
begin
mpz_init_set_si(rop, ROP_);
mpz_init_set_si(op1, OP_1);
mpz_submul_ui(rop, op1, OP_2);
assert(mpz_get_si(rop) = ROP_ - OP_1 * OP_2);
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_mul_2exp_test;
const
OP_1 = 10;
OP_2 = 10;
var rop, op1: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_mul_2exp(rop, op1, OP_2);
assert(mpz_get_si(rop) = OP_1 * (1 shl OP_2));
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_neg_test;
const OP_ = 1000;
var rop, op: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op, OP_);
mpz_neg(rop, op);
assert(mpz_get_si(rop) = -OP_);
mpz_clear(rop);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_abs_test;
const OP_ = -1000;
var rop, op: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op, OP_);
mpz_abs(rop, op);
assert(mpz_get_si(rop) = abs(OP_));
mpz_clear(rop);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_cdiv_q_test;
const
N_ = -17;
D_ = 4;
var q, n, d: mpz_t;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_cdiv_q(q, n, d);
assert(mpz_get_si(q) = ceil(N_ / D_));
mpz_clear(q);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_fdiv_q_test;
const
N_ = -17;
D_ = 4;
var q, n, d: mpz_t;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_fdiv_q(q, n, d);
assert(mpz_get_si(q) = floor(N_ / D_));
mpz_clear(q);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_tdiv_q_test;
const
N_ = -17;
D_ = 4;
var q, n, d: mpz_t;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_tdiv_q(q, n, d);
assert(mpz_get_si(q) = trunc(N_ / D_));
mpz_clear(q);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_cdiv_q_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var q, n: mpz_t;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
mpz_cdiv_q_2exp(q, n, B_);
assert(mpz_get_si(q) = ceil(N_ / D_));
mpz_clear(q);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_fdiv_q_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var q, n: mpz_t;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
mpz_fdiv_q_2exp(q, n, B_);
assert(mpz_get_si(q) = floor(N_ / D_));
mpz_clear(q);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_tdiv_q_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var q, n: mpz_t;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
mpz_tdiv_q_2exp(q, n, B_);
assert(mpz_get_si(q) = trunc(N_ / D_));
mpz_clear(q);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_cdiv_q_ui_test;
const
N_ = -17;
D_ = 4;
var
q, n: mpz_t;
ur: valuint;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
ur :=mpz_cdiv_q_ui(q, n, D_);
assert(mpz_get_si(q) = ceil(N_ / D_));
assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
mpz_clear(q);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_fdiv_q_ui_test;
const
N_ = -17;
D_ = 4;
var
q, n: mpz_t;
ur: valuint;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
ur :=mpz_fdiv_q_ui(q, n, D_);
assert(mpz_get_si(q) = floor(N_ / D_));
assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
mpz_clear(q);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_tdiv_q_ui_test;
const
N_ = -17;
D_ = 4;
var
q, n: mpz_t;
ur: valuint;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
ur :=mpz_tdiv_q_ui(q, n, D_);
assert(mpz_get_si(q) = trunc(N_ / D_));
assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
mpz_clear(q);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_cdiv_qr_test;
const
N_ = -17;
D_ = 4;
var q, r, n, d: mpz_t;
begin
mpz_init(q);
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_cdiv_qr(q, r, n, d);
assert(mpz_get_si(q) = ceil(N_ / D_));
assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
mpz_clear(q);
mpz_clear(r);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_fdiv_qr_test;
const
N_ = -17;
D_ = 4;
var q, r, n, d: mpz_t;
begin
mpz_init(q);
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_fdiv_qr(q, r, n, d);
assert(mpz_get_si(q) = floor(N_ / D_));
assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
mpz_clear(q);
mpz_clear(r);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_tdiv_qr_test;
const
N_ = -17;
D_ = 4;
var q, r, n, d: mpz_t;
begin
mpz_init(q);
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_tdiv_qr(q, r, n, d);
assert(mpz_get_si(q) = trunc(N_ / D_));
assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
mpz_clear(q);
mpz_clear(r);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_cdiv_qr_ui_test;
const
N_ = -17;
D_ = 4;
var
q, r, n: mpz_t;
ur: valuint;
begin
mpz_init(q);
mpz_init(r);
mpz_init_set_si(n, N_);
ur :=mpz_cdiv_qr_ui(q, r, n, D_);
assert(mpz_get_si(q) = ceil(N_ / D_));
assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
assert(ur - abs(mpz_get_si(r)) = 0);
mpz_clear(q);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_fdiv_qr_ui_test;
const
N_ = -17;
D_ = 4;
var
q, r, n: mpz_t;
ur: valuint;
begin
mpz_init(q);
mpz_init(r);
mpz_init_set_si(n, N_);
ur :=mpz_fdiv_qr_ui(q, r, n, D_);
assert(mpz_get_si(q) = floor(N_ / D_));
assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
assert(ur - abs(mpz_get_si(r)) = 0);
mpz_clear(q);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_tdiv_qr_ui_test;
const
N_ = -17;
D_ = 4;
var
q, r, n: mpz_t;
ur: valuint;
begin
mpz_init(q);
mpz_init(r);
mpz_init_set_si(n, N_);
ur :=mpz_tdiv_qr_ui(q, r, n, D_);
assert(mpz_get_si(q) = trunc(N_ / D_));
assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
assert(ur - abs(mpz_get_si(r)) = 0);
mpz_clear(q);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_cdiv_r_test;
const
N_ = -17;
D_ = 4;
var r, n, d: mpz_t;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_cdiv_r(r, n, d);
assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
mpz_clear(r);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_fdiv_r_test;
const
N_ = -17;
D_ = 4;
var r, n, d: mpz_t;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_fdiv_r(r, n, d);
assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
mpz_clear(r);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_tdiv_r_test;
const
N_ = -17;
D_ = 4;
var r, n, d: mpz_t;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_tdiv_r(r, n, d);
assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
mpz_clear(r);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_cdiv_r_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var r, n: mpz_t;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_cdiv_r_2exp(r, n, B_);
assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_fdiv_r_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var r, n: mpz_t;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_fdiv_r_2exp(r, n, B_);
assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_tdiv_r_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var r, n: mpz_t;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_tdiv_r_2exp(r, n, B_);
assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_cdiv_r_ui_test;
const
N_ = -17;
D_ = 4;
var
r, n: mpz_t;
ur: valuint;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
ur :=mpz_cdiv_r_ui(r, n, D_);
assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
assert(ur - abs(mpz_get_si(r)) = 0);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_fdiv_r_ui_test;
const
N_ = -17;
D_ = 4;
var
r, n: mpz_t;
ur: valuint;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
ur :=mpz_fdiv_r_ui(r, n, D_);
assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
assert(ur - abs(mpz_get_si(r)) = 0);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_tdiv_r_ui_test;
const
N_ = -17;
D_ = 4;
var
r, n: mpz_t;
ur: valuint;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
ur :=mpz_tdiv_r_ui(r, n, D_);
assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
assert(ur - abs(mpz_get_si(r)) = 0);
mpz_clear(r);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_cdiv_ui_test;
const
N_ = -17;
D_ = 4;
var n: mpz_t;
begin
mpz_init_set_si(n, N_);
assert(mpz_cdiv_ui(n, D_) - abs(N_ - ceil(N_ / D_) * D_) = 0);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_fdiv_ui_test;
const
N_ = -17;
D_ = 4;
var n: mpz_t;
begin
mpz_init_set_si(n, N_);
assert(mpz_fdiv_ui(n, D_) - abs(N_ - floor(N_ / D_) * D_) = 0);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_tdiv_ui_test;
const
N_ = -17;
D_ = 4;
var n: mpz_t;
begin
mpz_init_set_si(n, N_);
assert(mpz_tdiv_ui(n, D_) = abs(N_ - trunc(N_ / D_) * D_));
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_mod_test;
const
N_ = 17;
D_ = -4;
var r, n, d: mpz_t;
begin
mpz_init(r);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_mod(r, n, d);
assert(mpz_get_si(r) = N_ mod abs(D_));
mpz_clear(r);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_divexact_test;
const
N_ = -16;
D_ = 4;
var q, n, d: mpz_t;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
mpz_divexact(q, n, d);
assert(mpz_get_si(q) * D_ = N_);
mpz_clear(q);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_divexact_ui_test;
const
N_ = -16;
D_ = 4;
var q, n: mpz_t;
begin
mpz_init(q);
mpz_init_set_si(n, N_);
mpz_divexact_ui(q, n, D_);
assert(mpz_get_si(q) * D_ = N_);
mpz_clear(q);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_divisible_p_test;
const
N_ = -16;
D_ = 4;
var n, d: mpz_t;
begin
mpz_init_set_si(n, N_);
mpz_init_set_si(d, D_);
assert(mpz_divisible_p(n, d) <> 0);
mpz_set_si(n,mpz_get_si(n) + 1);
assert(mpz_divisible_p(n, d) = 0);
mpz_clear(n);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_divisible_ui_p_test;
const
N_ = -16;
D_ = 4;
var n: mpz_t;
begin
mpz_init_set_si(n, N_);
assert(mpz_divisible_ui_p(n, D_) <> 0);
mpz_set_si(n,mpz_get_si(n) + 1);
assert(mpz_divisible_ui_p(n, D_) = 0);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_divisible_2exp_p_test;
const
N_ = -16;
B_ = 2;
var n: mpz_t;
begin
mpz_init_set_si(n, N_);
assert(mpz_divisible_2exp_p(n, B_) <> 0);
mpz_set_si(n,mpz_get_si(n) + 1);
assert(mpz_divisible_ui_p(n, B_) = 0);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_congruent_p_test;
const
N_ = 23;
C_ = 6;
D_ = 17;
var n, c, d: mpz_t;
begin
mpz_init_set_si(n, N_);
mpz_init_set_si(c, C_);
mpz_init_set_si(d, D_);
assert(mpz_congruent_p(n, c, d) <> 0);
mpz_set_si(n,mpz_get_si(n) + 1);
assert(mpz_congruent_p(n, c, d) = 0);
mpz_clear(n);
mpz_clear(c);
mpz_clear(d);
end;
procedure TTestGmpBinding.mpz_congruent_2exp_p_test;
const
N_ = 23;
C_ = 7;
B_ = 4;
var n, c: mpz_t;
begin
mpz_init_set_si(n, N_);
mpz_init_set_si(c, C_);
assert(mpz_congruent_2exp_p(n, c, B_) <> 0);
mpz_set_si(n,mpz_get_si(n) + 1);
assert(mpz_congruent_2exp_p(n, c, B_) = 0);
mpz_clear(n);
mpz_clear(c);
end;
procedure TTestGmpBinding.mpz_congruent_ui_p_test;
const
N_ = 23;
C_ = 6;
D_ = 17;
var n: mpz_t;
begin
mpz_init_set_si(n, N_);
assert(mpz_congruent_ui_p(n, C_, D_) <> 0);
mpz_set_si(n,mpz_get_si(n) + 1);
assert(mpz_congruent_ui_p(n, C_, D_) = 0);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_powm_test;
const
N_EXP = 3;
N_MOD = 16;
ROP_ = 8;
var rop, base, exp, mod_: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(base, BASE10);
mpz_init_set_si(exp, N_EXP);
mpz_init_set_si(mod_, N_MOD);
mpz_powm(rop, base, exp, mod_);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(base);
mpz_clear(exp);
mpz_clear(mod_);
end;
procedure TTestGmpBinding.mpz_powm_ui_test;
const
N_EXP = 3;
N_MOD = 16;
ROP_ = 8;
var rop, base, mod_: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(base, BASE10);
mpz_init_set_si(mod_, N_MOD);
mpz_powm_ui(rop, base, N_EXP, mod_);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(base);
mpz_clear(mod_);
end;
procedure TTestGmpBinding.mpz_pow_ui_test;
const
BASE_ = 10;
EXP = 3;
var rop, base: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(base, BASE_);
mpz_pow_ui(rop, base, EXP);
assert(mpz_get_si(rop) = BASE_ ** EXP);
mpz_clear(rop);
mpz_clear(base);
end;
procedure TTestGmpBinding.mpz_ui_pow_ui_test;
const
BASE_ = 10;
EXP = 3;
var rop: mpz_t;
begin
mpz_init(rop);
mpz_ui_pow_ui(rop, BASE_, EXP);
assert(mpz_get_si(rop) = BASE_ ** EXP);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_root_test;
const
ROOT = 5;
N_ = 3;
var rop, op: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op, ROOT ** N_);
assert(mpz_root(rop, op, N_) <> 0);
assert(mpz_get_si(rop) = ROOT);
mpz_set_si(op, ROOT ** N_ + 1);
assert(mpz_root(rop, op, N_) = 0);
assert(mpz_get_si(rop) = ROOT);
mpz_clear(rop);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_rootrem_test;
const
ROOT_ = 5;
N_ = 3;
REM_ = 1;
var root, rem, u: mpz_t;
begin
assert(REM_ < ROOT_);
mpz_init(root);
mpz_init(rem);
mpz_init_set_si(u, ROOT_ ** N_);
mpz_rootrem(root, rem, u, N_);
assert(mpz_get_si(root) = ROOT_);
assert(mpz_get_si(rem) = 0);
mpz_set_si(u, ROOT_ ** N_ + REM_);
mpz_rootrem(root, rem, u, N_);
assert(mpz_get_si(root) = ROOT_);
assert(mpz_get_si(rem) = REM_);
mpz_clear(root);
mpz_clear(rem);
mpz_clear(u);
end;
procedure TTestGmpBinding.mpz_sqrt_test;
const ROOT = 5;
var rop, op: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op, ROOT ** 2);
mpz_sqrt(rop, op);
assert(mpz_get_si(rop) = ROOT);
mpz_clear(rop);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_sqrtrem_test;
const
ROOT = 5;
REM = 1;
var rop1, rop2, op: mpz_t;
begin
mpz_init(rop1);
mpz_init(rop2);
mpz_init_set_si(op, ROOT ** 2 + REM);
mpz_sqrtrem(rop1, rop2, op);
assert(mpz_get_si(rop1) = ROOT);
assert(mpz_get_si(rop2) = REM);
mpz_clear(rop1);
mpz_clear(rop2);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_perfect_power_p_test;
const
ROOT = 3;
EXP = 3;
var op: mpz_t;
begin
mpz_init_set_si(op, ROOT ** EXP);
assert(mpz_perfect_power_p(op) <> 0);
mpz_set_si(op, ROOT ** EXP + 1);
assert(mpz_perfect_power_p(op) = 0);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_perfect_square_p_test;
const ROOT = 3;
var op: mpz_t;
begin
mpz_init_set_si(op, ROOT ** 2);
assert(mpz_perfect_square_p(op) <> 0);
mpz_set_si(op, ROOT ** 2 or 2);
assert(mpz_perfect_square_p(op) = 0);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_probab_prime_p_test;
const
N_ = 127;
REPS = 5;
var n: mpz_t;
begin
mpz_init_set_si(n, N_);
assert(mpz_probab_prime_p(n, REPS) = 2);
mpz_set_si(n, N_ + 1);
assert(mpz_probab_prime_p(n, REPS) = 0);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_nextprime_test;
const
PRIME3 = 5;
PRIME4 = 7;
var rop, op: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op, PRIME3);
mpz_nextprime(rop, op);
assert(mpz_get_si(rop) = PRIME4);
mpz_clear(rop);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_gcd_test;
const
OP_1 = 42;
OP_2 = 56;
ROP_ = 14;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_gcd(rop, op1, op2);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_gcd_ui_test;
const
OP_1 = 42;
OP_2 = 56;
ROP_ = 14;
var rop, op1: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
assert(mpz_gcd_ui(rop, op1, OP_2) = ROP_);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_gcdext_test;
const
A_ = 42;
B_ = 56;
G_ = 14;
var g, s, t, a, b: mpz_t;
begin
mpz_init(g);
mpz_init(s);
mpz_init(t);
mpz_init_set_si(a, A_);
mpz_init_set_si(b, B_);
mpz_gcdext(g, s, t, a, b);
assert(mpz_get_si(g) = G_);
assert(A_ *mpz_get_si(s) + B_ *mpz_get_si(t) = G_);
mpz_clear(g);
mpz_clear(s);
mpz_clear(t);
mpz_clear(a);
mpz_clear(b);
end;
procedure TTestGmpBinding.mpz_lcm_test;
const
OP_1 = 21;
OP_2 = 6;
ROP_ = 42;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_lcm(rop, op1, op2);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_lcm_ui_test;
const
OP_1 = 21;
OP_2 = 6;
ROP_ = 42;
var rop, op1: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_lcm_ui(rop, op1, OP_2);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_invert_test;
const
OP_1 = 256;
OP_2 = 337;
ROP_ = 104;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
assert(mpz_invert(rop, op1, op2) <> 0);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_jacobi_test;
const
B0 = 11;
A0 = 13 * B0;
AM1 = 1001;
BM1 = 9907;
A1 = 4;
B1 = 7;
var a, b: mpz_t;
begin
mpz_init_set_si(a, A0);
mpz_init_set_si(b, B0);
assert(mpz_jacobi(a, b) = 0);
mpz_set_si(a, AM1);
mpz_set_si(b, BM1);
assert(mpz_jacobi(a, b) = -1);
mpz_set_si(a, A1);
mpz_set_si(b, B1);
assert(mpz_jacobi(a, b) = 1);
mpz_clear(a);
mpz_clear(b);
end;
procedure TTestGmpBinding.mpz_kronecker_si_test;
const
A_ = 8;
B0 = 6;
BM1 = 5;
B1 = 7;
var a: mpz_t;
begin
mpz_init_set_si(a, A_);
assert(mpz_kronecker_si(a, B1) = 1);
assert(mpz_kronecker_si(a, B0) = 0);
assert(mpz_kronecker_si(a, BM1) = -1);
mpz_clear(a);
end;
procedure TTestGmpBinding.mpz_kronecker_ui_test;
const
A_ = 8;
B0 = 6;
BM1 = 5;
B1 = 7;
var a: mpz_t;
begin
mpz_init_set_si(a, A_);
assert(mpz_kronecker_ui(a, B1) = 1);
assert(mpz_kronecker_ui(a, B0) = 0);
assert(mpz_kronecker_ui(a, BM1) = -1);
mpz_clear(a);
end;
procedure TTestGmpBinding.mpz_si_kronecker_test;
const
A_ = 8;
B0 = 6;
BM1 = 5;
B1 = 7;
var b: mpz_t;
begin
mpz_init_set_si(b, B1);
assert(mpz_si_kronecker(A_, b) = 1);
mpz_set_si(b, B0);
assert(mpz_si_kronecker(A_, b) = 0);
mpz_set_si(b, BM1);
assert(mpz_si_kronecker(A_, b) = -1);
mpz_clear(b);
end;
procedure TTestGmpBinding.mpz_ui_kronecker_test;
const
A_ = 8;
B0 = 6;
BM1 = 5;
B1 = 7;
var b: mpz_t;
begin
mpz_init_set_si(b, B1);
assert(mpz_ui_kronecker(A_, b) = 1);
mpz_set_si(b, B0);
assert(mpz_ui_kronecker(A_, b) = 0);
mpz_set_si(b, BM1);
assert(mpz_ui_kronecker(A_, b) = -1);
mpz_clear(b);
end;
procedure TTestGmpBinding.mpz_remove_test;
const
F_ = 5;
OP_ = 3 * F_ * 7;
ROP_ = OP_ div F_;
var rop, op, f: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op, OP_);
mpz_init_set_si(f, F_);
assert(mpz_remove(rop, op, f) = 1);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(op);
mpz_clear(f);
end;
procedure TTestGmpBinding.mpz_fac_ui_test;
const
OP = 4;
ROP_ = 2 * 3 * 4;
var rop: mpz_t;
begin
mpz_init(rop);
mpz_fac_ui(rop, OP);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_bin_ui_test;
const
N_ = 7;
K = 3;
ROP_ = 35;
var rop, n: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(n, N_);
mpz_bin_ui(rop, n, K);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
mpz_clear(n);
end;
procedure TTestGmpBinding.mpz_bin_uiui_test;
const
N = 7;
K = 3;
ROP_ = 35;
var rop: mpz_t;
begin
mpz_init(rop);
mpz_bin_uiui(rop, N, K);
assert(mpz_get_si(rop) = ROP_);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_fib_ui_test;
const
N = 10;
FN_ = 55;
var fn: mpz_t;
begin
mpz_init(fn);
mpz_fib_ui(fn, N);
assert(mpz_get_si(fn) = FN_);
mpz_clear(fn);
end;
procedure TTestGmpBinding.mpz_fib2_ui_test;
const
N = 10;
FN_ = 55;
FNSUB1_ = 34;
var fn, fnsub1: mpz_t;
begin
mpz_init(fn);
mpz_init(fnsub1);
mpz_fib2_ui(fn, fnsub1, N);
assert(mpz_get_si(fn) = FN_);
assert(mpz_get_si(fnsub1) = FNSUB1_);
mpz_clear(fn);
mpz_clear(fnsub1);
end;
procedure TTestGmpBinding.mpz_lucnum_ui_test;
const
N = 10;
LN_ = 123;
var ln: mpz_t;
begin
mpz_init(ln);
mpz_lucnum_ui(ln, N);
assert(mpz_get_si(ln) = LN_);
mpz_clear(ln);
end;
procedure TTestGmpBinding.mpz_lucnum2_ui_test;
const
N = 10;
LN_ = 123;
LNSUB1_ = 76;
var ln, lnsub1: mpz_t;
begin
mpz_init(ln);
mpz_init(lnsub1);
mpz_lucnum2_ui(ln, lnsub1, N);
assert(mpz_get_si(ln) = LN_);
assert(mpz_get_si(lnsub1) = LNSUB1_);
mpz_clear(ln);
mpz_clear(lnsub1);
end;
procedure TTestGmpBinding.mpz_cmp_test;
const
OP_1 = -10;
OP_2 = OP_1 - 1;
var op1, op2: mpz_t;
begin
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
assert(mpz_cmp(op1, op2) > 0);
mpz_set_si(op2, OP_1);
assert(mpz_cmp(op1, op2) = 0);
mpz_set_si(op2, OP_1 + 1);
assert(mpz_cmp(op1, op2) < 0);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_cmp_d_test;
const
OP_1 = -10;
var op1: mpz_t;
begin
mpz_init_set_si(op1, OP_1);
assert(mpz_cmp_d(op1, OP_1 - 1) > 0);
assert(mpz_cmp_d(op1, OP_1) = 0);
assert(mpz_cmp_d(op1, OP_1 + 1) < 0);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_cmp_si_test;
const
OP_1 = -10;
var op1: mpz_t;
begin
mpz_init_set_si(op1, OP_1);
assert(mpz_cmp_si(op1, OP_1 - 1) > 0);
assert(mpz_cmp_si(op1, OP_1) = 0);
assert(mpz_cmp_si(op1, OP_1 + 1) < 0);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_cmp_ui_test;
const
OP_1 = 10;
var op1: mpz_t;
begin
mpz_init_set_si(op1, OP_1);
assert(mpz_cmp_ui(op1, OP_1 - 1) > 0);
assert(mpz_cmp_ui(op1, OP_1) = 0);
assert(mpz_cmp_ui(op1, OP_1 + 1) < 0);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_cmpabs_test;
const
OP_1 = -10;
OP_2 = -OP_1 - 1;
var op1, op2: mpz_t;
begin
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, -OP_2);
assert(mpz_cmpabs(op1, op2) > 0);
mpz_set_si(op2, -OP_1);
assert(mpz_cmpabs(op1, op2) = 0);
mpz_set_si(op2, -OP_1 + 1);
assert(mpz_cmpabs(op1, op2) < 0);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_cmpabs_d_test;
const OP_1 = -10;
var op1: mpz_t;
begin
mpz_init_set_si(op1, OP_1);
assert(mpz_cmpabs_d(op1, -OP_1 - 1) > 0);
assert(mpz_cmpabs_d(op1, -OP_1) = 0);
assert(mpz_cmpabs_d(op1, -OP_1 + 1) < 0);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_cmpabs_ui_test;
const OP_1 = -10;
var op1: mpz_t;
begin
mpz_init_set_si(op1, OP_1);
assert(mpz_cmpabs_ui(op1, -OP_1 - 1) > 0);
assert(mpz_cmpabs_ui(op1, -OP_1) = 0);
assert(mpz_cmpabs_ui(op1, -OP_1 + 1) < 0);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_and_test;
const
OP_1 = $c;
OP_2 = $a;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_and(rop, op1, op2);
assert(mpz_get_si(rop) = OP_1 and OP_2);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_ior_test;
const
OP_1 = $c;
OP_2 = $a;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_ior(rop, op1, op2);
assert(mpz_get_si(rop) = OP_1 or OP_2);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_xor_test;
const
OP_1 = $c;
OP_2 = $a;
var rop, op1, op2: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
mpz_xor(rop, op1, op2);
assert(mpz_get_si(rop) = OP_1 xor OP_2);
mpz_clear(rop);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_com_test;
const
OP_1 = 2;
var rop, op1: mpz_t;
begin
mpz_init(rop);
mpz_init_set_si(op1, OP_1);
mpz_com(rop, op1);
assert(mpz_get_si(rop) = not OP_1 );
mpz_clear(rop);
mpz_clear(op1);
end;
procedure TTestGmpBinding.mpz_popcount_test;
const
OP_ = $55AA;
N = 8;
var op: mpz_t;
begin
mpz_init_set_si(op, OP_);
assert(mpz_popcount(op) = N);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_hamdist_test;
const
OP_1 = $55;
OP_2 = $7A;
N = 5;
var op1, op2: mpz_t;
begin
mpz_init_set_si(op1, OP_1);
mpz_init_set_si(op2, OP_2);
assert(mpz_hamdist(op1, op2) = N);
mpz_clear(op1);
mpz_clear(op2);
end;
procedure TTestGmpBinding.mpz_scan0_test;
const
OP_ = $F75;
STARTING_BIT = 4;
N = 7;
var op: mpz_t;
begin
mpz_init_set_si(op, OP_);
assert(mpz_scan0(op, STARTING_BIT) = N);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_scan1_test;
const
OP_ = $85;
STARTING_BIT = 4;
N = 7;
var op: mpz_t;
begin
mpz_init_set_si(op, OP_);
assert(mpz_scan1(op, STARTING_BIT) = N);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_setbit_test;
const
ROP_ = $F75;
BIT_INDEX = 7;
var rop: mpz_t;
begin
mpz_init_set_ui(rop, ROP_);
mpz_setbit(rop, BIT_INDEX);
assert(mpz_get_ui(rop) = ROP_ or (1 shl BIT_INDEX));
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_clrbit_test;
const
ROP_ = $F75;
BIT_INDEX = 9;
var rop: mpz_t;
begin
mpz_init_set_ui(rop, ROP_);
mpz_clrbit(rop, BIT_INDEX);
assert(mpz_get_ui(rop) = ROP_ and not (1 shl BIT_INDEX));
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_combit_test;
const
ROP_ = $F75;
BIT_INDEX = 7;
var rop: mpz_t;
begin
mpz_init_set_ui(rop, ROP_);
mpz_combit(rop, BIT_INDEX);
assert(mpz_get_ui(rop) = ROP_ xor (1 shl BIT_INDEX));
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_tstbit_test;
const
ROP_ = $F75;
BIT_INDEX1 = 7;
BIT_INDEX2 = 8;
var rop: mpz_t;
begin
mpz_init_set_ui(rop, ROP_);
assert(longbool(mpz_tstbit(rop, BIT_INDEX1)) = longbool(ROP_ and (1 shl BIT_INDEX1)));
assert(longbool(mpz_tstbit(rop, BIT_INDEX2)) = longbool(ROP_ and (1 shl BIT_INDEX2)));
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_urandomb_test;
const
B = 8 * (sizeof(valuint) - 1);
N = 1 shl B;
var
rop: mpz_t;
state: randstate_t;
begin
mp_randinit_default(state);
mpz_init(rop);
mpz_urandomb(rop, state, B);
assert(mpz_cmp_ui(rop, N) < 0);
mpz_clear(rop);
mp_randclear(state);
end;
procedure TTestGmpBinding.mpz_urandomm_test;
const
N_ = 1000000;
var
rop, n: mpz_t;
state: randstate_t;
begin
mp_randinit_default(state);
mpz_init(rop);
mpz_init_set_ui(n, N_);
mpz_urandomm(rop, state, n);
assert(mpz_cmp_ui(rop, N_) < 0);
mpz_clear(rop);
mpz_clear(n);
mp_randclear(state);
end;
procedure TTestGmpBinding.mpz_rrandomb_test;
const
B = 8 * sizeof(valuint) - 2;
N = 1 shl B;
var
rop: mpz_t;
state: randstate_t;
begin
mp_randinit_default(state);
mpz_init(rop);
mpz_rrandomb(rop, state, B);
assert(mpz_cmp_ui(rop, N) < 0);
mpz_clear(rop);
mp_randclear(state);
end;
procedure TTestGmpBinding.mpz_fits_ushort_p_test;
var op: mpz_t;
begin
mpz_init_set_ui(op, high(word));
assert(longbool(mpz_fits_ushort_p(op)));
mpz_add_ui(op, op, 1);
assert(not longbool(mpz_fits_ushort_p(op)));
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_fits_sshort_p_test;
var op: mpz_t;
begin
mpz_init_set_si(op, high(smallint));
assert(longbool(mpz_fits_sshort_p(op)));
mpz_add_ui(op, op, 1);
assert(not longbool(mpz_fits_sshort_p(op)));
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_fits_uint_p_test;
var op: mpz_t;
begin
mpz_init_set_ui(op, high(cardinal));
assert(longbool(mpz_fits_uint_p(op)));
mpz_add_ui(op, op, 1);
assert(not longbool(mpz_fits_uint_p(op)));
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_fits_sint_p_test;
var op: mpz_t;
begin
mpz_init_set_si(op, high(integer));
assert(longbool(mpz_fits_sint_p(op)));
mpz_add_ui(op, op, 1);
assert(not longbool(mpz_fits_sint_p(op)));
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_fits_ulong_p_test;
var op: mpz_t;
begin
mpz_init_set_ui(op, high(valuint));
assert(longbool(mpz_fits_ulong_p(op)));
mpz_add_ui(op, op, 1);
assert(not longbool(mpz_fits_ulong_p(op)));
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_fits_slong_p_test;
var op: mpz_t;
begin
mpz_init_set_si(op, high(valsint));
assert(longbool(mpz_fits_slong_p(op)));
mpz_add_ui(op, op, 1);
assert(not longbool(mpz_fits_slong_p(op)));
mpz_clear(op);
end;
procedure TTestGmpBinding.mpz_sizeinbase_test;
const
OP_ = 1000000;
var rop: mpz_t;
begin
mpz_init_set_ui(rop, OP_);
assert(mpz_sizeinbase(rop, BASE10) - length(inttostr(OP_)) = 0);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpz_size_test;
var rop: mpz_t;
begin
mpz_init(rop);
assert(mpz_size(rop) = 0);
mpz_add_ui(rop, rop, 1);
assert(mpz_size(rop) = 1);
mpz_clear(rop);
end;
procedure TTestGmpBinding.mpq_init_test;
var rational: mpq_t;
begin
mpq_init(rational);
assert(mpq_cmp_ui(rational, 0, 1) = 0);
mpq_clear(rational);
end;
procedure TTestGmpBinding.mpq_clear_test;
var rational: mpq_t;
begin
mpq_init(rational);
mpq_clear(rational);
end;
procedure TTestGmpBinding.mpq_set_ui_test;
const
OP_1 = 13;
OP_2 = 17;
var rational: mpq_t;
begin
mpq_init(rational);
mpq_set_ui(rational, OP_1, OP_2);
assert(mpq_cmp_ui(rational, OP_1, OP_2) = 0);
mpq_clear(rational);
end;
procedure TTestGmpBinding.mpq_set_si_test;
const
OP_1 = -13;
OP_2 = 17;
var rational: mpq_t;
begin
mpq_init(rational);
mpq_set_si(rational, OP_1, OP_2);
assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
mpq_clear(rational);
end;
procedure TTestGmpBinding.mpq_canonicalize_test;
const
OP_1 = -13;
OP_2 = 17;
CF = 11;
var rational: mpq_t;
begin
mpq_init(rational);
mpq_set_si(rational, CF * OP_1, CF * OP_2);
mpq_canonicalize(rational);
assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
mpq_clear(rational);
end;
procedure TTestGmpBinding.mpq_set_test;
const
OP_1 = -13;
OP_2 = 17;
var rational1, rational2: mpq_t;
begin
mpq_init(rational1);
mpq_init(rational2);
mpq_set_si(rational2, OP_1, OP_2);
mpq_set(rational1, rational2);
assert(mpq_cmp_si(rational1, OP_1, OP_2) = 0);
mpq_clear(rational1);
mpq_clear(rational2);
end;
procedure TTestGmpBinding.mpq_setmpz_test;
const
OP_1 = -13;
var
rational: mpq_t;
op: mpz_t;
begin
mpq_init(rational);
mpz_init_set_si(op, OP_1);
mpq_set_z(rational, op);
assert(mpq_cmp_si(rational, OP_1, 1) = 0);
mpq_clear(rational);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpq_set_str_test;
const
OP_1 = -13;
OP_2 = 17;
var rational: mpq_t;
begin
mpq_init(rational);
assert(mpq_set_str(rational, pchar(inttostr(OP_1) + '/' + inttostr(OP_2)), BASE10) = 0);
assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
assert(mpq_set_str(rational, pchar(inttostr(OP_1) + '*' + inttostr(OP_2)), BASE10) <> 0);
mpq_clear(rational);
end;
procedure TTestGmpBinding.mpq_swap_test;
const
ROP_1N = -13;
ROP_1D = 17;
ROP_2N = -23;
ROP_2D = 31;
var rop1, rop2: mpq_t;
begin
mpq_init(rop1);
mpq_init(rop2);
mpq_set_si(rop1, ROP_1N, ROP_1D);
mpq_set_si(rop2, ROP_2N, ROP_2D);
mpq_swap(rop1, rop2);
assert(mpq_cmp_si(rop1, ROP_2N, ROP_2D) = 0);
assert(mpq_cmp_si(rop2, ROP_1N, ROP_1D) = 0);
mpq_clear(rop1);
mpq_clear(rop2);
end;
procedure TTestGmpBinding.mpq_get_d_test;
const
OP_1 = -1;
OP_2 = 2;
var op: mpq_t;
begin
mpq_init(op);
mpq_set_si(op, OP_1, OP_2);
assert(mpq_get_d(op) = OP_1 / OP_2);
mpq_clear(op);
end;
procedure TTestGmpBinding.mpq_set_d_test;
const
OP_1 = -1;
OP_2 = 2;
var rop: mpq_t;
begin
mpq_init(rop);
mpq_set_d(rop, OP_1 / OP_2);
assert(mpq_cmp_si(rop, OP_1, OP_2) = 0);
mpq_clear(rop);
end;
procedure TTestGmpBinding.mpq_set_f_test;
const OP_ = -10;
var
op: mpf_t;
rop: mpq_t;
begin
mpf_init_set_si(op, OP_);
mpq_init(rop);
mpq_set_f(rop, op);
assert(mpq_get_d(rop) = OP_);
mpq_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpq_get_str_test;
const
OP_1 = -1;
OP_2 = 2;
var
op: mpq_t;
p: pchar;
begin
mpq_init(op);
mpq_set_si(op, OP_1, OP_2);
p := mpq_get_str(nil, BASE10, op);
assert(p = inttostr(OP_1) + '/' + inttostr(OP_2));
freemem(p);
mpq_clear(op);
end;
procedure TTestGmpBinding.mpq_add_test;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var sum, addend1, addend2: mpq_t;
begin
mpq_init(sum);
mpq_init(addend1);
mpq_init(addend2);
mpq_set_si(addend1, N1, D1);
mpq_set_si(addend2, N2, D2);
mpq_add(sum, addend1, addend2);
assert(mpq_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
mpq_clear(sum);
mpq_clear(addend1);
mpq_clear(addend2);
end;
procedure TTestGmpBinding.mpq_sub_test;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var difference, minuend, subtrahend: mpq_t;
begin
mpq_init(difference);
mpq_init(minuend);
mpq_init(subtrahend);
mpq_set_si(minuend, N1, D1);
mpq_set_si(subtrahend, N2, D2);
mpq_sub(difference, minuend, subtrahend);
assert(mpq_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
mpq_clear(difference);
mpq_clear(minuend);
mpq_clear(subtrahend);
end;
procedure TTestGmpBinding.mpq_mul_test;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var product, multiplier, multiplicant: mpq_t;
begin
mpq_init(product);
mpq_init(multiplier);
mpq_init(multiplicant);
mpq_set_si(multiplier, N1, D1);
mpq_set_si(multiplicant, N2, D2);
mpq_mul(product, multiplier, multiplicant);
assert(mpq_cmp_si(product, N1 * N2, D1 * D2) = 0);
mpq_clear(product);
mpq_clear(multiplier);
mpq_clear(multiplicant);
end;
procedure TTestGmpBinding.mpq_mul_2exp_test;
const
N1 = 5;
D1 = 3;
OP_2 = 2;
var rop, op1: mpq_t;
begin
mpq_init(rop);
mpq_init(op1);
mpq_set_si(op1, N1, D1);
mpq_mul_2exp(rop, op1, OP_2);
assert(mpq_cmp_si(rop, N1 * (1 shl OP_2), D1) = 0);
mpq_clear(rop);
mpq_clear(op1);
end;
procedure TTestGmpBinding.mpq_div_test;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var quotient, dividend, divisor: mpq_t;
begin
mpq_init(quotient);
mpq_init(dividend);
mpq_init(divisor);
mpq_set_si(dividend, N1, D1);
mpq_set_si(divisor, N2, D2);
mpq_div(quotient, dividend, divisor);
assert(mpq_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
mpq_clear(quotient);
mpq_clear(dividend);
mpq_clear(divisor);
end;
procedure TTestGmpBinding.mpq_div_2exp_test;
const
N1 = 5;
D1 = 3;
OP_2 = 2;
var rop, op1: mpq_t;
begin
mpq_init(rop);
mpq_init(op1);
mpq_set_si(op1, N1, D1);
mpq_div_2exp(rop, op1, OP_2);
assert(mpq_cmp_si(rop, N1, D1 * (1 shl OP_2)) = 0);
mpq_clear(rop);
mpq_clear(op1);
end;
procedure TTestGmpBinding.mpq_neg_test;
const
N1 = -5;
D1 = 3;
var negated_operand, operand: mpq_t;
begin
mpq_init(negated_operand);
mpq_init(operand);
mpq_set_si(operand, N1, D1);
mpq_neg(negated_operand, operand);
assert(mpq_cmp_si(negated_operand, -N1, D1) = 0);
mpq_clear(negated_operand);
mpq_clear(operand);
end;
procedure TTestGmpBinding.mpq_abs_test;
const
N1 = 5;
D1 = 3;
var rop, op: mpq_t;
begin
mpq_init(rop);
mpq_init(op);
mpq_set_si(op, -N1, D1);
mpq_abs(rop, op);
assert(mpq_cmp_si(rop, N1, D1) = 0);
mpq_clear(rop);
mpq_clear(op);
end;
procedure TTestGmpBinding.mpq_inv_test;
const
N1 = -5;
D1 = 3;
var inverted_number, number: mpq_t;
begin
mpq_init(inverted_number);
mpq_init(number);
mpq_set_si(number, N1, D1);
mpq_inv(inverted_number, number);
assert(mpq_cmp_si(inverted_number, -D1, -N1) = 0);
mpq_clear(inverted_number);
mpq_clear(number);
end;
procedure TTestGmpBinding.mpq_cmp_test;
const
N1 = -7;
D1 = 5;
var op1, op2: mpq_t;
begin
mpq_init(op1);
mpq_init(op2);
mpq_set_si(op1, N1, D1);
mpq_set_si(op2, N1, D1);
assert(mpq_cmp(op1, op2) = 0);
mpq_set_si(op1, N1 + 1, D1);
assert(mpq_cmp(op1, op2) > 0);
mpq_set_si(op1, N1 - 1, D1);
assert(mpq_cmp(op1, op2) < 0);
mpq_clear(op1);
mpq_clear(op2);
end;
procedure TTestGmpBinding.mpq_cmp_si_test;
const
N1 = -7;
D1 = 5;
var op1: mpq_t;
begin
mpq_init(op1);
mpq_set_si(op1, N1, D1);
assert(mpq_cmp_si(op1, N1, D1) = 0);
assert(mpq_cmp_si(op1, N1 - 1, D1) > 0);
assert(mpq_cmp_si(op1, N1 + 1, D1) < 0);
mpq_clear(op1);
end;
procedure TTestGmpBinding.mpq_cmp_ui_test;
const
N1 = 7;
D1 = 5;
var op1: mpq_t;
begin
mpq_init(op1);
mpq_set_si(op1, N1, D1);
assert(mpq_cmp_ui(op1, N1, D1) = 0);
assert(mpq_cmp_ui(op1, N1 - 1, D1) > 0);
assert(mpq_cmp_ui(op1, N1 + 1, D1) < 0);
mpq_clear(op1);
end;
procedure TTestGmpBinding.mpq_equal_test;
const
N1 = -7;
D1 = 5;
var op1, op2: mpq_t;
begin
mpq_init(op1);
mpq_init(op2);
mpq_set_si(op1, N1, D1);
mpq_set_si(op2, N1, D1);
assert(longbool(mpq_equal(op1, op2)));
mpq_set_si(op1, N1 + 1, D1);
assert(not longbool(mpq_equal(op1, op2)));
mpq_set_si(op1, N1 - 1, D1);
assert(not longbool(mpq_equal(op1, op2)));
mpq_clear(op1);
mpq_clear(op2);
end;
procedure TTestGmpBinding.mpq_get_num_test;
const
N1 = -7;
D1 = 5;
var
rational: mpq_t;
numerator: mpz_t;
begin
mpq_init(rational);
mpz_init(numerator);
mpq_set_si(rational, N1, D1);
mpq_get_num(numerator, rational);
assert(mpz_get_si(numerator) = N1);
mpq_clear(rational);
mpz_clear(numerator);
end;
procedure TTestGmpBinding.mpq_get_den_test;
const
N1 = -7;
D1 = 5;
var
rational: mpq_t;
denominator: mpz_t;
begin
mpq_init(rational);
mpz_init(denominator);
mpq_set_si(rational, N1, D1);
mpq_get_den(denominator, rational);
assert(mpz_get_si(denominator) = D1);
mpq_clear(rational);
mpz_clear(denominator);
end;
procedure TTestGmpBinding.mpq_set_num_test;
const
N1 = -7;
D1 = 5;
N2 = 3;
var
rational: mpq_t;
numerator: mpz_t;
begin
mpq_init(rational);
mpz_init_set_si(numerator, N2);
mpq_set_si(rational, N1, D1);
mpq_set_num(rational, numerator);
assert(mpq_cmp_si(rational, N2, D1) = 0);
mpq_clear(rational);
mpz_clear(numerator);
end;
procedure TTestGmpBinding.mpq_set_den_test;
const
N1 = -7;
D1 = 5;
D2 = 3;
var
rational: mpq_t;
denominator: mpz_t;
begin
mpq_init(rational);
mpz_init_set_si(denominator, D2);
mpq_set_si(rational, N1, D1);
mpq_set_den(rational, denominator);
assert(mpq_cmp_si(rational, N1, D2) = 0);
mpq_clear(rational);
mpz_clear(denominator);
end;
procedure TTestGmpBinding.mpf_get_default_prec_test;
begin
assert(mpf_get_default_prec > 0);
end;
procedure TTestGmpBinding.mpf_set_default_prec_test;
var prec: valuint;
begin
prec := mpf_get_default_prec;
mpf_set_default_prec(2 * prec);
assert(mpf_get_default_prec = 2 * prec);
mpf_set_default_prec(prec);
end;
procedure TTestGmpBinding.mpf_init_test;
var x: mpf_t;
begin
mpf_init(x);
assert(mpf_get_prec(x) = mpf_get_default_prec);
mpf_clear(x);
end;
procedure TTestGmpBinding.mpf_init2_test;
var x: mpf_t;
begin
mpf_init2(x, 2 * mpf_get_default_prec);
assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
mpf_clear(x);
end;
procedure TTestGmpBinding.mpf_clear_test;
var x: mpf_t;
begin
mpf_init(x);
mpf_clear(x);
end;
procedure TTestGmpBinding.mpf_get_prec_test;
var x: mpf_t;
begin
mpf_init(x);
mpf_set_prec(x, 2 * mpf_get_default_prec);
assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
mpf_clear(x);
end;
procedure TTestGmpBinding.mpf_set_prec_test;
var x: mpf_t;
begin
mpf_init(x);
mpf_set_prec(x, 2 * mpf_get_default_prec);
assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
mpf_clear(x);
end;
procedure TTestGmpBinding.mpf_set_prec_raw_test;
const N = 10;
var x: mpf_t;
begin
mpf_init2(x, N * mpf_get_default_prec);
mpf_set_prec_raw(x, mpf_get_default_prec);
mpf_set_prec_raw(x, N * mpf_get_default_prec);
mpf_clear(x);
end;
procedure TTestGmpBinding.mpf_set_q_test;
const OP_ = -10;
var
op: mpq_t;
rop: mpf_t;
begin
mpq_init(op);
mpf_init(rop);
mpq_set_si(op, OP_, 1);
mpf_set_q(rop, op);
assert(mpf_get_si(rop) = OP_);
mpf_clear(rop);
mpq_clear(op);
end;
procedure TTestGmpBinding.mpf_set_ui_test;
const OP = 1000000;
var rop: mpf_t;
begin
mpf_init(rop);
mpf_set_ui(rop, OP);
assert(mpf_get_ui(rop) = OP);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_get_ui_test;
const OP = 1000000;
var rop: mpf_t;
begin
mpf_init(rop);
mpf_set_ui(rop, OP);
assert(mpf_get_ui(rop) = OP);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_set_si_test;
const OP = -1000000;
var rop: mpf_t;
begin
mpf_init(rop);
mpf_set_si(rop, OP);
assert(mpf_get_si(rop) = OP);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_get_si_test;
const OP = -1000000;
var rop: mpf_t;
begin
mpf_init(rop);
mpf_set_si(rop, OP);
assert(mpf_get_si(rop) = OP);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_set_test;
const N = -1000000;
var rop, op: mpf_t;
begin
mpf_init(rop);
mpf_init_set_si(op, N);
mpf_set(rop, op);
assert(mpf_get_si(rop) = N);
mpf_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_set_str_test;
const N = -123;
var rop: mpf_t;
begin
mpf_init(rop);
assert(mpf_set_str(rop, pchar(inttostr(N)), BASE10) = 0);
assert(mpf_get_si(rop) = N);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_swap_test;
const
ROP_1 = -13;
ROP_2 = -23;
var rop1, rop2: mpf_t;
begin
mpf_init_set_si(rop1, ROP_1);
mpf_init_set_si(rop2, ROP_2);
mpf_swap(rop1, rop2);
assert(mpf_get_si(rop1) = ROP_2);
assert(mpf_get_si(rop2) = ROP_1);
mpf_clear(rop1);
mpf_clear(rop2);
end;
procedure TTestGmpBinding.mpf_get_d_test;
const N = -1.5;
var rop: mpf_t;
begin
mpf_init_set_d(rop, N);
assert(mpf_get_d(rop) = N);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_set_d_test;
const N = -1.5;
var rop: mpf_t;
begin
mpf_init(rop);
mpf_set_d(rop, N);
assert(mpf_get_d(rop) = N);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_setmpz_test;
const
OP_1 = -13;
var
rop: mpf_t;
op: mpz_t;
begin
mpf_init(rop);
mpz_init_set_si(op, OP_1);
mpf_set_z(rop, op);
assert(mpf_get_si(rop) = OP_1);
mpf_clear(rop);
mpz_clear(op);
end;
procedure TTestGmpBinding.mpf_get_d_2exp_test;
const
M = 0.5;
E = 4;
N = (1 shl E) div 2;
var
rop: mpf_t;
exp: valsint;
begin
mpf_init_set_d(rop, N);
exp := -1;
assert(mpf_get_d_2exp(exp, rop) = M);
assert(exp = E);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_get_str_test;
const
N = 3.1416;
S = '31416';
E = 1;
var
op: mpf_t;
p: pchar;
exp: mp_exp_t;
begin
mpf_init_set_d(op, N);
p := mpf_get_str(nil, exp, BASE10, length(S), op);
assert(p = S);
assert(exp = E);
freemem(p);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_add_test;
const
OP1_ = 1;
OP2_ = 2;
var rop, op1, op2: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_init_set_d(op2, OP2_);
mpf_add(rop, op1, op2);
assert(mpf_get_d(rop) = OP1_ + OP2_);
mpf_clear(rop);
mpf_clear(op1);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_add_ui_test;
const
OP1_ = 1;
OP2_ = 2;
var rop, op1: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_add_ui(rop, op1, OP2_);
assert(mpf_get_d(rop) = OP1_ + OP2_);
mpf_clear(rop);
mpf_clear(op1);
end;
procedure TTestGmpBinding.mpf_sub_test;
const
OP1_ = 3;
OP2_ = 1;
var rop, op1, op2: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_init_set_d(op2, OP2_);
mpf_sub(rop, op1, op2);
assert(mpf_get_d(rop) = OP1_ - OP2_);
mpf_clear(rop);
mpf_clear(op1);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_sub_ui_test;
const
OP1_ = 3;
OP2_ = 1;
var rop, op1: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_sub_ui(rop, op1, OP2_);
assert(mpf_get_d(rop) = OP1_ - OP2_);
mpf_clear(rop);
mpf_clear(op1);
end;
procedure TTestGmpBinding.mpf_ui_sub_test;
const
OP1_ = 3;
OP2_ = 1;
var rop, op2: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op2, OP2_);
mpf_ui_sub(rop, OP1_, op2);
assert(mpf_get_d(rop) = OP1_ - OP2_);
mpf_clear(rop);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_mul_test;
const
OP1_ = 2;
OP2_ = 3;
var rop, op1, op2: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_init_set_d(op2, OP2_);
mpf_mul(rop, op1, op2);
assert(mpf_get_d(rop) = OP1_ * OP2_);
mpf_clear(rop);
mpf_clear(op1);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_mul_ui_test;
const
OP1_ = 2;
OP2_ = 3;
var rop, op1: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_mul_ui(rop, op1, OP2_);
assert(mpf_get_d(rop) = OP1_ * OP2_);
mpf_clear(rop);
mpf_clear(op1);
end;
procedure TTestGmpBinding.mpf_mul_2exp_test;
const
OP1_ = 3;
OP2_ = 4;
var rop, op1: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_mul_2exp(rop, op1, OP2_);
assert(mpf_get_d(rop) = OP1_ * (1 shl OP2_));
mpf_clear(rop);
mpf_clear(op1);
end;
procedure TTestGmpBinding.mpf_div_test;
const
OP1_ = 6;
OP2_ = 2;
var rop, op1, op2: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_init_set_d(op2, OP2_);
mpf_div(rop, op1, op2);
assert(mpf_get_d(rop) = OP1_ / OP2_);
mpf_clear(rop);
mpf_clear(op1);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_div_ui_test;
const
OP1_ = 6;
OP2_ = 2;
var rop, op1: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_div_ui(rop, op1, OP2_);
assert(mpf_get_d(rop) = OP1_ / OP2_);
mpf_clear(rop);
mpf_clear(op1);
end;
procedure TTestGmpBinding.mpf_ui_div_test;
const
OP1_ = 6;
OP2_ = 2;
var rop, op2: mpf_t;
begin
mpf_init(rop);
mpf_init_set_si(op2, OP2_);
mpf_ui_div(rop, OP1_, op2);
assert(mpf_get_d(rop) = OP1_ / OP2_);
mpf_clear(rop);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_div_2exp_test;
const
OP1_ = 16;
OP2_ = 2;
var rop, op1: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_div_2exp(rop, op1, OP2_);
assert(mpf_get_d(rop) = OP1_ / (1 shl OP2_));
mpf_clear(rop);
mpf_clear(op1);
end;
procedure TTestGmpBinding.mpf_sqrt_test;
const
OP_ = 4;
var rop, op: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op, OP_);
mpf_sqrt(rop, op);
assert(mpf_get_d(rop) = sqrt(OP_));
mpf_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_sqrt_ui_test;
const
OP_ = 4;
var rop: mpf_t;
begin
mpf_init(rop);
mpf_sqrt_ui(rop, OP_);
assert(mpf_get_d(rop) = sqrt(OP_));
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_pow_ui_test;
const
OP1_ = 3;
OP2_ = 2;
var rop, op1: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_pow_ui(rop, op1, OP2_);
assert(mpf_get_d(rop) = OP1_ ** OP2_);
mpf_clear(rop);
mpf_clear(op1);
end;
procedure TTestGmpBinding.mpf_neg_test;
const
OP_ = 4;
var rop, op: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op, OP_);
mpf_neg(rop, op);
assert(mpf_get_d(rop) = -OP_);
mpf_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_abs_test;
const OP_ = -4;
var rop, op: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op, OP_);
mpf_abs(rop, op);
assert(mpf_get_d(rop) = -OP_);
mpf_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_cmp_test;
const OP_1 = -10;
var op1, op2: mpf_t;
begin
mpf_init_set_si(op1, OP_1);
mpf_init_set_si(op2, OP_1);
assert(mpf_cmp(op1, op2) = 0);
mpf_set_si(op2, OP_1 + 1);
assert(mpf_cmp(op1, op2) < 0);
mpf_set_si(op2, OP_1 - 1);
assert(mpf_cmp(op1, op2) > 0);
mpf_clear(op1);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_cmp_d_test;
const OP_ = -10;
var op: mpf_t;
begin
mpf_init_set_si(op, OP_);
assert(mpf_cmp_d(op, OP_) = 0);
assert(mpf_cmp_d(op, OP_ + 1) < 0);
assert(mpf_cmp_d(op, OP_ - 1) > 0);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_cmp_si_test;
const OP_ = -10;
var op: mpf_t;
begin
mpf_init_set_si(op, OP_);
assert(mpf_cmp_si(op, OP_) = 0);
assert(mpf_cmp_si(op, OP_ + 1) < 0);
assert(mpf_cmp_si(op, OP_ - 1) > 0);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_cmp_ui_test;
const OP_ = 10;
var op: mpf_t;
begin
mpf_init_set_si(op, OP_);
assert(mpf_cmp_ui(op, OP_) = 0);
assert(mpf_cmp_ui(op, OP_ + 1) < 0);
assert(mpf_cmp_ui(op, OP_ - 1) > 0);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_eq_test;
const
OP_1 = 10;
OP_3 = 8;
var op1, op2: mpf_t;
begin
mpf_init_set_si(op1, OP_1);
mpf_init_set_si(op2, OP_1);
assert(mpf_eq(op1, op2, OP_3) <> 0);
mpf_clear(op1);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_reldiff_test;
const
OP1_ = 4;
OP2_ = 2;
var rop, op1, op2: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op1, OP1_);
mpf_init_set_d(op2, OP2_);
mpf_reldiff(rop, op1, op2);
assert(mpf_get_d(rop) = abs(OP1_ - OP2_) / OP1_);
mpf_clear(rop);
mpf_clear(op1);
mpf_clear(op2);
end;
procedure TTestGmpBinding.mpf_ceil_test;
const N = 3.1;
var rop, op: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op, N);
mpf_ceil(rop, op);
assert(mpf_get_d(rop) = ceil(N));
mpf_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_floor_test;
const N = 3.9;
var rop, op: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op, N);
mpf_floor(rop, op);
assert(mpf_get_d(rop) = floor(N));
mpf_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_trunc_test;
const N = -3.9;
var rop, op: mpf_t;
begin
mpf_init(rop);
mpf_init_set_d(op, N);
mpf_trunc(rop, op);
assert(mpf_get_d(rop) = trunc(N));
mpf_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_integer_p_test;
const
N1 = 10;
N2 = 10.1;
var op: mpf_t;
begin
mpf_init_set_si(op, N1);
assert(longbool(mpf_integer_p(op)));
mpf_set_d(op, N2);
assert(not longbool(mpf_integer_p(op)));
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_fits_ushort_p_test;
var op: mpf_t;
begin
mpf_init_set_ui(op, high(word));
assert(longbool(mpf_fits_ushort_p(op)));
mpf_add_ui(op, op, 1);
assert(not longbool(mpf_fits_ushort_p(op)));
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_fits_sshort_p_test;
var op: mpf_t;
begin
mpf_init_set_ui(op, high(smallint));
assert(longbool(mpf_fits_sshort_p(op)));
mpf_add_ui(op, op, 1);
assert(not longbool(mpf_fits_sshort_p(op)));
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_fits_uint_p_test;
var op: mpf_t;
begin
mpf_init_set_ui(op, high(cardinal));
assert(longbool(mpf_fits_uint_p(op)));
mpf_add_ui(op, op, 1);
assert(not longbool(mpf_fits_uint_p(op)));
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_fits_sint_p_test;
var op: mpf_t;
begin
mpf_init_set_ui(op, high(integer));
assert(longbool(mpf_fits_sint_p(op)));
mpf_add_ui(op, op, 1);
assert(not longbool(mpf_fits_sint_p(op)));
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_fits_ulong_p_test;
var op: mpf_t;
begin
mpf_init_set_ui(op, high(valuint));
assert(longbool(mpf_fits_ulong_p(op)));
mpf_add_ui(op, op, 1);
assert(not longbool(mpf_fits_ulong_p(op)));
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_fits_slong_p_test;
var op: mpf_t;
begin
mpf_init_set_ui(op, high(valsint));
assert(longbool(mpf_fits_slong_p(op)));
mpf_add_ui(op, op, 1);
assert(not longbool(mpf_fits_slong_p(op)));
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_urandomb_test;
const NBITS = 100;
var
rop: mpf_t;
state: randstate_t;
cmp: longint;
begin
mp_randinit_default(state);
mpf_init(rop);
mpf_urandomb(rop, state, NBITS);
cmp := mpf_cmp_ui(rop, 0);
assert(cmp >= 0);
assert(mpf_cmp_ui(rop, 1) < 0);
mpf_clear(rop);
mp_randclear(state);
end;
procedure TTestGmpBinding.mpf_random2_test;
var
rop: mpf_t;
begin
mpf_init(rop);
mpf_random2(rop, 1, 1);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_init_set_test;
const N = -1000000;
var rop, op: mpf_t;
begin
mpf_init_set_si(op, N);
mpf_init_set(rop, op);
assert(mpf_get_si(rop) = N);
mpf_clear(rop);
mpf_clear(op);
end;
procedure TTestGmpBinding.mpf_init_set_d_test;
const N = -1.5;
var rop: mpf_t;
begin
mpf_init_set_d(rop, N);
assert(mpf_get_d(rop) = N);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_init_set_si_test;
const N = -5;
var rop: mpf_t;
begin
mpf_init_set_si(rop, N);
assert(mpf_get_si(rop) = N);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_init_set_str_test;
const N = -123;
var rop: mpf_t;
begin
mpf_init_set_str(rop, pchar(inttostr(N)), BASE10);
assert(mpf_get_si(rop) = N);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpf_init_set_ui_test;
const N = 5;
var rop: mpf_t;
begin
mpf_init_set_ui(rop, N);
assert(mpf_get_ui(rop) = N);
mpf_clear(rop);
end;
procedure TTestGmpBinding.mpn_add_n_test;
var
rop, s1, s2: mp_limb_t;
begin
s1 := high(mp_limb_t);
s2 := s1;
rop := 2;
assert(mpn_add_n(@rop, @s1, @s2, 1) = 1);
assert(rop = high(mp_limb_t) - 1);
end;
procedure TTestGmpBinding.mpn_add_1_test;
var
rop, s1: mp_limb_t;
begin
s1 := high(mp_limb_t);
rop := 2;
assert(mpn_add_1(@rop, @s1, 1, high(mp_limb_t)) = 1);
assert(rop = high(mp_limb_t) - 1);
end;
procedure TTestGmpBinding.mpn_add_test;
var
rop, s1, s2: mp_limb_t;
begin
s1 := high(mp_limb_t);
s2 := s1;
rop := 2;
assert(mpn_add(@rop, @s1, 1, @s2, 1) = 1);
assert(rop = high(mp_limb_t) - 1);
end;
procedure TTestGmpBinding.mpn_sub_n_test;
var
rop, s1, s2: mp_limb_t;
begin
s1 := 0;
s2 := high(mp_limb_t);
rop := 2;
assert(mpn_sub_n(@rop, @s1, @s2, 1) = 1);
assert(rop = 1);
end;
procedure TTestGmpBinding.mpn_sub_1_test;
var
rop, s1: mp_limb_t;
begin
s1 := 0;
rop := 2;
assert(mpn_sub_1(@rop, @s1, 1, high(mp_limb_t)) = 1);
assert(rop = 1);
end;
procedure TTestGmpBinding.mpn_sub_test;
var
rop, s1, s2: mp_limb_t;
begin
s1 := 0;
s2 := high(mp_limb_t);
rop := 2;
assert(mpn_sub(@rop, @s1, 1, @s2, 1) = 1);
assert(rop = 1);
end;
procedure TTestGmpBinding.mpn_mul_n_test;
var
rop: array[0..1] of mp_limb_t;
s1, s2: mp_limb_t;
begin
s1 := high(mp_limb_t);
s2 := s1;
mpn_mul_n(@rop, @s1, @s2, 1);
assert(rop[0] = 1);
assert(rop[1] = high(mp_limb_t) - 1);
end;
procedure TTestGmpBinding.mpn_mul_1_test;
var
rop: array[0..1] of mp_limb_t;
s1: mp_limb_t;
begin
s1 := high(mp_limb_t);
assert(mpn_mul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
assert(rop[0] = 1);
end;
procedure TTestGmpBinding.mpn_mul_test;
var
rop: array[0..1] of mp_limb_t;
s1, s2: mp_limb_t;
begin
s1 := high(mp_limb_t);
s2 := s1;
assert(mpn_mul(@rop, @s1, 1, @s2, 1) = high(mp_limb_t) - 1);
assert(rop[0] = 1);
assert(rop[1] = high(mp_limb_t) - 1);
end;
procedure TTestGmpBinding.mpn_addmul_1_test;
var
rop: array[0..1] of mp_limb_t;
s1: mp_limb_t;
begin
rop[0] := 1;
rop[1] := 0;
s1 := high(mp_limb_t);
assert(mpn_addmul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
assert(rop[0] = 2);
end;
procedure TTestGmpBinding.mpn_submul_1_test;
var
rop: array[0..1] of mp_limb_t;
s1: mp_limb_t;
begin
rop[0] := 1;
rop[1] := 0;
s1 := high(mp_limb_t);
assert(mpn_submul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
assert(rop[0] = 0);
end;
procedure TTestGmpBinding.mpn_tdiv_qr_test;
const
N_ = 19;
D_ = 4;
var
q, r: array[0..1] of mp_limb_t;
n, d: mp_limb_t;
begin
n := N_;
d := D_;
q[0] := 0;
q[1] := 0;
r[0] := 0;
r[1] := 0;
mpn_tdiv_qr(@q, @r, 0, @n, 1, @d, 1);
assert(q[0] = N_ div D_);
assert(r[0] = N_ mod D_);
end;
procedure TTestGmpBinding.mpn_divrem_1_test;
const
N_ = 19;
D_ = 4;
var r1, s2: mp_limb_t;
begin
r1 := 0;
s2 := N_;
assert(mpn_divrem_1(@r1, 0, @s2, 1, D_) = N_ mod D_);
assert(r1 = N_ div D_);
end;
procedure TTestGmpBinding.mpn_divexact_by3c_test;
const
K = 3;
N_ = 17;
var r, s: mp_limb_t;
begin
r := 0;
s := K * N_;
assert(mpn_divexact_by3c(@r, @s, 1, 0) = 0);
assert(r = N_);
s := K * N_ + 1;
assert(mpn_divexact_by3c(@r, @s, 1, 0) <> 0);
end;
procedure TTestGmpBinding.mpn_mod_1_test;
const
N_ = 19;
D_ = 4;
var s1: mp_limb_t;
begin
s1 := N_;
assert(mpn_mod_1(@s1, 1, D_) = N_ mod D_);
end;
procedure TTestGmpBinding.mpn_lshift_test;
var r, s: mp_limb_t;
begin
r := 0;
s := high(mp_limb_t);
assert(mpn_lshift(@r, @s, 1, 1) = 1);
assert(r = high(mp_limb_t) - 1);
end;
procedure TTestGmpBinding.mpn_rshift_test;
var r, s: mp_limb_t;
begin
r := 0;
s := high(mp_limb_t);
assert(mpn_rshift(@r, @s, 1, 1) = valuint(1) shl (bits_per_limb - 1));
assert(r = high(mp_limb_t) shr 1);
end;
procedure TTestGmpBinding.mpn_cmp_test;
const S1_ = 10;
var s1, s2: mp_limb_t;
begin
s1 := S1_;
S2 := S1_;
assert(mpn_cmp(@s1, @s2, 1) = 0);
S2 := S1_ - 1;
assert(mpn_cmp(@s1, @s2, 1) > 0);
S2 := S1_ + 1;
assert(mpn_cmp(@s1, @s2, 1) < 0);
end;
procedure TTestGmpBinding.mpn_gcd_test;
const
S1_ = 30;
S2_ = 105;
RP_ = 15;
var r, s1, s2: mp_limb_t;
begin
s1 := S1_;
s2 := S2_;
r := 0;
assert(mpn_gcd(@r, @s1, 1, @s2, 1) = 1);
assert(r = RP_);
end;
procedure TTestGmpBinding.mpn_gcd_1_test;
const
S1_ = 30;
S2_ = 105;
R_ = 15;
var s1: mp_limb_t;
begin
s1 := S1_;
assert(mpn_gcd_1(@s1, 1, S2_) = R_);
end;
procedure TTestGmpBinding.mpn_gcdext_test;
const
S1_ = 3 * 5;
S2_ = 2 * 3;
R1_ = 3;
var
r1, r2, s1, s2: array[0..1] of mp_limb_t;
r2n: mp_size_t;
k: valsint;
begin
s1[0] := S1_;
s1[1] := 0;
s2[0] := S2_;
s2[1] := 0;
assert(mpn_gcdext(@r1, @r2, r2n, @s1, 1, @s2, 1) = 1);
assert(r2n = 1);
assert(r1[0] = R1_);
k := (valsint(r1[0]) - valsint(r2[0]) * valsint(s1[0])) div valsint(s2[0]);
assert(valsint(r1[0]) = valsint(r2[0]) * valsint(s1[0]) + k * valsint(s2[0]));
end;
procedure TTestGmpBinding.mpn_sqrtrem_test;
const
ROOT = 3;
var r1, r2, s: mp_limb_t;
begin
s := ROOT ** 2 + ROOT - 1;
assert(mpn_sqrtrem(@r1, @r2, @s, 1) = 1);
assert(r1 = ROOT);
assert(r2 = ROOT - 1);
end;
procedure TTestGmpBinding.mpn_get_str_test;
const N = uint64($FEDCBA9876543210);
var
str: array[0..2 * sizeof(mp_limb_t)] of byte;
s1: mp_limb_t;
i: integer;
begin
s1 := N and (high(mp_limb_t) - 1);
assert(mpn_get_str(@str, BASE16, @s1, 1) = high(str));
for i := 0 to high(str) - 1 do
assert(str[i] = high(str) - i - 1);
end;
procedure TTestGmpBinding.mpn_set_str_test;
const N = uint64($FEDCBA9876543210);
var
r: mp_limb_t;
str: array[0..2 * sizeof(mp_limb_t)] of byte;
i: integer;
begin
for i := 0 to high(str) - 1 do
str[i] := high(str) - i - 1;
assert(mpn_set_str(@r, @str, high(str), BASE16) = 1);
assert(r = N and (high(mp_limb_t) - 1));
end;
procedure TTestGmpBinding.mpn_scan0_test;
const
S1_ = $F75;
STARTING_BIT = 4;
N = 7;
var s1: mp_limb_t;
begin
s1 := S1_;
assert(mpn_scan0(@s1, STARTING_BIT) = N);
end;
procedure TTestGmpBinding.mpn_scan1_test;
const
S1_ = $85;
STARTING_BIT = 4;
N = 7;
var s1: mp_limb_t;
begin
s1 := S1_;
assert(mpn_scan1(@s1, STARTING_BIT) = N);
end;
procedure TTestGmpBinding.mpn_popcount_test;
const
S1_ = $55AA;
N = 8;
var s1: mp_limb_t;
begin
s1 := S1_;
assert(mpn_popcount(@s1, 1) = N);
end;
procedure TTestGmpBinding.mpn_hamdist_test;
const
S1_ = $55;
S2_ = $7A;
N = 5;
var s1, s2: mp_limb_t;
begin
s1 := S1_;
s2 := S2_;
assert(mpn_hamdist(@s1, @s2, 1) = N);
end;
procedure TTestGmpBinding.mpn_perfect_square_p_test;
const ROOT = 3;
var s1: mp_limb_t;
begin
s1 := ROOT ** 2;
assert(mpn_perfect_square_p(@s1, 1) <> 0);
s1 := s1 or 2;
assert(mpn_perfect_square_p(@s1, 1) = 0);
end;
procedure TTestGmpBinding.mpn_random_test;
var r1: array[0..2] of mp_limb_t;
begin
mpn_random(@r1, high(r1) + 1);
assert((r1[2] <> 0) and ((r1[0] <> r1[1]) or (r1[0] <> r1[2]) or (r1[1] <> r1[2])));
end;
procedure TTestGmpBinding.mpn_random2_test;
var r1: array[0..2] of mp_limb_t;
begin
mpn_random2(@r1, high(r1) + 1);
assert((r1[2] <> 0) and ((r1[0] <> r1[1]) or (r1[0] <> r1[2]) or (r1[1] <> r1[2])));
end;
procedure TTestGmpBinding.bits_per_limb_test;
begin
assert(bits_per_limb = 8 * sizeof(mp_limb_t));
end;
procedure TTestGmpBinding.version_test;
function isvernum(s: string; first, last: integer): boolean;
var i: integer;
begin
i := strtointdef(copy(s, first, last - first + 1), -1);
result := i >= 0;
end;
const DOT = '.';
var
v: string;
dot1, dot2: integer;
begin
v := version;
dot1 := pos(DOT, v);
assert(dot1 <> 0);
dot2 := posex(DOT, v, dot1 + 1);
assert(dot2 <> 0);
assert(isvernum(v, 1, dot1 - 1));
assert(isvernum(v, dot1 + 1, dot2 - 1));
assert(isvernum(v, dot2 + 1, length(v)));
end;
{ TTestGmpExtensions }
procedure TTestGmpExtensions.randinit_default_test;
var state: MPRandState;
begin
randinit_default(state);
assert(rnd_test(state.Ptr^));
end;
procedure TTestGmpExtensions.randinit_mt_test;
var state: MPRandState;
begin
randinit_mt(state);
assert(rnd_test(state.Ptr^));
end;
procedure TTestGmpExtensions.randinit_lc_2exp_test;
const
A_ = 3;
C = 5;
M2EXP = 8;
var
state: MPRandState;
a: MPInteger;
begin
z_init_set_ui(a, A_);
randinit_lc_2exp(state, a, C, M2EXP);
assert(rnd_test(state.Ptr^));
end;
procedure TTestGmpExtensions.randinit_lc_2exp_size_test;
var state: MPRandState;
begin
assert(randinit_lc_2exp_size(state, 0));
assert(rnd_test(state.Ptr^));
end;
procedure TTestGmpExtensions.randinit_set_test;
var rop, op: MPRandState;
begin
randinit_default(op);
randinit_set(rop, op);
assert(rnd_test(rop.Ptr^));
end;
procedure TTestGmpExtensions.randclear_test;
var state: MPRandState;
begin
randinit_default(state);
randclear(state);
end;
procedure TTestGmpExtensions.randseed_test;
var
state: MPRandState;
seed: MPInteger;
begin
randinit_default(state);
z_init_set_ui(seed, 0);
randseed(state, seed);
end;
procedure TTestGmpExtensions.randseed_ui_test;
var state: MPRandState;
begin
randinit_default(state);
randseed_ui(state, 0);
end;
procedure TTestGmpExtensions.urandomb_ui_test;
const
B = 8 * (sizeof(valuint) - 1);
N = 1 shl B;
var
state: MPRandState;
r1, r2, r3: valuint;
begin
randinit_default(state);
r1 := urandomb_ui(state, B);
r2 := urandomb_ui(state, B);
r3 := urandomb_ui(state, B);
assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
end;
procedure TTestGmpExtensions.urandomm_ui_test;
const N = high(valuint);
var
state: MPRandState;
r1, r2, r3: valuint;
begin
randinit_default(state);
r1 := urandomm_ui(state, N);
r2 := urandomm_ui(state, N);
r3 := urandomm_ui(state, N);
assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
end;
//procedure TTestGmpExtensions.asprintf_test;
//const
// N = 123456;
// S = '123456';
//var
// z: MPInteger;
// p: pchar;
//begin
// z_init_set_ui(z, N);
// assert(asprintf(p, Z_FMT, [@z]) = length(S));
// assert(p = S);
// freemem(p);
// z_clear(z);
//end;
//
//procedure TTestGmpExtensions.asprintf_test2;
//const
// N = 123456;
// S = '123456';
//var
// z: MPInteger;
// p: pchar;
//begin
// z_init_set_ui(z, N);
// assert(asprintf(p, Z_FMT, @z) = length(S));
// assert(p = S);
// freemem(p);
// z_clear(z);
//end;
//
//procedure TTestGmpExtensions.snprintf_test;
//const
// N = 123456;
// S = '123456';
//var
// z: MPInteger;
// buf: pchar;
//begin
// z_init_set_ui(z, N);
// getmem(buf, length(S) + 1);
// assert(snprintf(buf, length(S) + 1, Z_FMT, [@z]) = length(S));
// assert(buf = S);
// freemem(buf);
// z_clear(z);
//end;
//
//procedure TTestGmpExtensions.snprintf_test2;
//const
// N = 123456;
// S = '123456';
//var
// z: MPInteger;
// buf: pchar;
//begin
// z_init_set_ui(z, N);
// getmem(buf, length(S) + 1);
// assert(snprintf(buf, length(S) + 1, Z_FMT, @z) = length(S));
// assert(buf = S);
// freemem(buf);
// z_clear(z);
//end;
//
//procedure TTestGmpExtensions.sprintf_test;
//const
// N = 123456;
// S = '123456';
//var
// z: MPInteger;
// buf: pchar;
//begin
// z_init_set_ui(z, N);
// getmem(buf, length(S) + 1);
// assert(sprintf(buf, Z_FMT, [@z]) = length(S));
// assert(buf = S);
// freemem(buf);
// z_clear(z);
//end;
//
//procedure TTestGmpExtensions.sprintf_test2;
//const
// N = 123456;
// S = '123456';
//var
// z: MPInteger;
// buf: pchar;
//begin
// z_init_set_ui(z, N);
// getmem(buf, length(S) + 1);
// assert(sprintf(buf, Z_FMT, @z) = length(S));
// assert(buf = S);
// freemem(buf);
// z_clear(z);
//end;
//
//procedure TTestGmpExtensions.sscanf_test;
//const
// N = 3;
// D = 2;
//var q: mpq_t;
//begin
// q_init(q);
// assert(sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, [@q]) = 1);
// assert(q_cmp_ui(q, N, D) = 0);
// q_clear(q);
//end;
//
//procedure TTestGmpExtensions.sscanf_test2;
//const
// N = 3;
// D = 2;
//var q: mpq_t;
//begin
// q_init(q);
// assert(sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, @q) = 1);
// assert(q_cmp_ui(q, N, D) = 0);
// q_clear(q);
//end;
procedure TTestGmpExtensions.z_init_test;
var integer_: MPInteger;
begin
z_init(integer_);
assert(z_get_si(integer_) = 0);
end;
procedure TTestGmpExtensions.z_clear_test;
const N = 1000000;
var integer_: MPInteger;
begin
z_init2(integer_, N);
z_clear(integer_);
assert(z_get_si(integer_) = 0);
end;
procedure TTestGmpExtensions.z_init2_test;
const N = 1000000;
var integer_: MPInteger;
begin
z_init2(integer_, N);
assert(z_get_si(integer_) = 0);
end;
procedure TTestGmpExtensions.z_init_set_si_test;
const N = -1000000;
var rop: MPInteger;
begin
z_init_set_si(rop, N);
assert(z_get_si(rop) = N);
end;
procedure TTestGmpExtensions.z_init_set_ui_test;
const N = 1000000;
var rop: MPInteger;
begin
z_init_set_ui(rop, N);
assert(z_get_ui(rop) = N);
end;
procedure TTestGmpExtensions.z_init_set_d_test;
const N = -1000000;
var rop: MPInteger;
begin
z_init_set_d(rop, N);
assert(z_get_si(rop) = N);
end;
procedure TTestGmpExtensions.z_init_set_test;
const N = -1000000;
var rop, op: MPInteger;
begin
z_init_set_si(op, N);
z_init_set(rop, op);
assert(z_get_si(rop) = N);
end;
procedure TTestGmpExtensions.z_init_set_str_test;
const N = 1000000;
var rop: MPInteger;
begin
assert(z_init_set_str(rop, IntToStr(N), BASE10));
assert(z_get_si(rop) = N);
end;
procedure TTestGmpExtensions.z_realloc_test;
const N = 1000;
var integer_: MPInteger;
begin
z_init(integer_);
z_realloc(integer_, N);
end;
procedure TTestGmpExtensions.z_realloc2_test;
const N = 1000;
var integer_: MPInteger;
begin
z_init(integer_);
z_realloc2(integer_, N);
end;
procedure TTestGmpExtensions.z_getlimbn_test;
const N = 1234;
var op: MPInteger;
begin
z_init_set_ui(op, N);
assert(z_getlimbn(op, 0) = N);
end;
procedure TTestGmpExtensions.z_export_test;
type t = word;
const
N = 1000000;
BUF_HIGH = sizeof(N) div sizeof(t);
var
export_op, import_op: MPInteger;
buf: array[0..BUF_HIGH] of t;
count: sizeuint;
begin
z_init_set_si(export_op, N);
z_init(import_op);
z_export(buf, count, -1, sizeof(t), 0, 0, export_op);
z_import(import_op, count, -1, sizeof(t), 0, 0, buf);
assert(z_get_si(export_op) = z_get_si(import_op));
end;
procedure TTestGmpExtensions.z_import_test;
type t = word;
const
N = 1000000;
BUF_HIGH = sizeof(N) div sizeof(t);
var
export_op, import_op: MPInteger;
buf: array[0..BUF_HIGH] of t;
count: sizeuint;
begin
z_init_set_si(export_op, N);
z_init(import_op);
z_export(buf, count, -1, sizeof(t), 0, 0, export_op);
z_import(import_op, count, -1, sizeof(t), 0, 0, buf);
assert(z_get_si(export_op) = z_get_si(import_op));
end;
procedure TTestGmpExtensions.z_swap_test;
const
ROP_1 = -1000;
ROP_2 = 1000000;
var rop1, rop2: MPInteger;
begin
z_init_set_si(rop1, ROP_1);
z_init_set_si(rop2, ROP_2);
z_swap(rop1, rop2);
assert(z_get_si(rop1) = ROP_2);
assert(z_get_si(rop2) = ROP_1);
end;
procedure TTestGmpExtensions.z_set_test;
const OP_ = 1000000;
var rop, op: MPInteger;
begin
z_init(rop);
z_init_set_si(op, OP_);
z_set(rop, op);
assert(z_get_si(rop) = OP_);
end;
procedure TTestGmpExtensions.z_set_d_test;
const OP_ = 1000000;
var rop: MPInteger;
begin
z_init(rop);
z_set_d(rop, OP_);
assert(z_get_si(rop) = OP_);
end;
procedure TTestGmpExtensions.z_set_f_test;
const OP_ = -10;
var
op: MPFloat;
rop: MPInteger;
begin
f_init_set_si(op, OP_);
z_init(rop);
z_set_f(rop, op);
assert(z_get_si(rop) = OP_);
end;
procedure TTestGmpExtensions.z_set_q_test;
const OP_ = -10;
var
op: MPRational;
rop: MPInteger;
begin
q_init(op);
z_init(rop);
q_set_si(op, OP_, 1);
z_set_q(rop, op);
assert(z_get_si(rop) = OP_);
end;
procedure TTestGmpExtensions.z_set_si_test;
const OP_ = -1000000;
var rop: MPInteger;
begin
z_init(rop);
z_set_si(rop, OP_);
assert(z_get_si(rop) = OP_);
end;
procedure TTestGmpExtensions.z_set_str_test;
const OP_ = -1000000;
var rop: MPInteger;
begin
z_init(rop);
assert(z_set_str(rop, IntToStr(OP_), BASE10));
assert(z_get_si(rop) = OP_);
end;
procedure TTestGmpExtensions.z_set_ui_test;
const OP_ = 1000000;
var rop: MPInteger;
begin
z_init(rop);
z_set_ui(rop, OP_);
assert(z_get_si(rop) = OP_);
end;
procedure TTestGmpExtensions.z_get_d_test;
const N = -1000;
var op: MPInteger;
begin
z_init_set_si(op, N);
assert(z_get_d(op) = N);
end;
procedure TTestGmpExtensions.z_get_d_2exp_test;
const
N_LG2 = 4;
N = 1 shl N_LG2;
var
op: MPInteger;
exp: mp_exp_t;
begin
z_init_set_si(op, N);
assert(z_get_d_2exp(exp, op) = 1 / 2);
assert(exp = N_LG2 + 1);
end;
procedure TTestGmpExtensions.z_get_si_test;
const N = -1000000;
var op: MPInteger;
begin
z_init_set_si(op, N);
assert(z_get_si(op) = N);
end;
procedure TTestGmpExtensions.z_get_str_test;
const N = -1000000;
var
op: MPInteger;
p: pchar;
s, s0, s1: String;
begin
z_init_set_si(op, N);
s0 := inttostr(N);
s := z_get_str(BASE10, op);
assert(s = s0);
p := z_get_str(nil, BASE10, op);
assert(p = s0);
freemem(p);
setlength(s1, length(s0));
assert(pointer(z_get_str(pchar(s1), BASE10, op)) = pointer(s1));
assert(s1 = s0);
end;
procedure TTestGmpExtensions.z_get_ui_test;
const N = 1000000;
var op: MPInteger;
begin
z_init_set_ui(op, N);
assert(z_get_ui(op) = N);
end;
procedure TTestGmpExtensions.z_add_test;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1, op2, sum: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_add(rop, op1, op2);
assert(z_get_si(rop) = OP_1 + OP_2);
sum := z_add(op1, op2);
assert(z_get_si(sum) = OP_1 + OP_2);
end;
procedure TTestGmpExtensions.z_add_ui_test;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1, sum: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_add_ui(rop, op1, OP_2);
assert(z_get_si(rop) = OP_1 + OP_2);
sum := z_add_ui(op1, OP_2);
assert(z_get_si(sum) = OP_1 + OP_2);
end;
procedure TTestGmpExtensions.z_sub_test;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1, op2, diff: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_sub(rop, op1, op2);
assert(z_get_si(rop) = OP_1 - OP_2);
diff := z_sub(op1, op2);
assert(z_get_si(diff) = OP_1 - OP_2);
end;
procedure TTestGmpExtensions.z_sub_ui_test;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1, diff: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_sub_ui(rop, op1, OP_2);
assert(z_get_si(rop) = OP_1 - OP_2);
diff := z_sub_ui(op1, OP_2);
assert(z_get_si(diff) = OP_1 - OP_2);
end;
procedure TTestGmpExtensions.z_ui_sub_test;
const
OP_1 = 1000;
OP_2 = 1000000;
var rop, op2, diff: MPInteger;
begin
z_init(rop);
z_init_set_si(op2, OP_2);
z_ui_sub(rop, OP_1, op2);
assert(z_get_si(rop) = OP_1 - OP_2);
diff := z_ui_sub(OP_1, op2);
assert(z_get_si(diff) = OP_1 - OP_2);
end;
procedure TTestGmpExtensions.z_mul_test;
const
OP_1 = -10;
OP_2 = 1000;
var rop, op1, op2, prod: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_mul(rop, op1, op2);
assert(z_get_si(rop) = OP_1 * OP_2);
prod := z_mul(op1, op2);
assert(z_get_si(prod) = OP_1 * OP_2);
end;
procedure TTestGmpExtensions.z_mul_si_test;
const
OP_1 = 10;
OP_2 = -1000;
var rop, op1, prod: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_mul_si(rop, op1, OP_2);
assert(z_get_si(rop) = OP_1 * OP_2);
prod := z_mul_si(op1, OP_2);
assert(z_get_si(prod) = OP_1 * OP_2);
end;
procedure TTestGmpExtensions.z_mul_ui_test;
const
OP_1 = -10;
OP_2 = 1000;
var rop, op1, prod: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_mul_ui(rop, op1, OP_2);
assert(z_get_si(rop) = OP_1 * OP_2);
prod := z_mul_ui(op1, OP_2);
assert(z_get_si(prod) = OP_1 * OP_2);
end;
procedure TTestGmpExtensions.z_addmul_test;
const
ROP_ = 10;
OP_1 = -100;
OP_2 = 1000;
var rop, op1, op2: MPInteger;
begin
z_init_set_si(rop, ROP_);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_addmul(rop, op1, op2);
assert(z_get_si(rop) = ROP_ + OP_1 * OP_2);
end;
procedure TTestGmpExtensions.z_addmul_ui_test;
const
ROP_ = 10;
OP_1 = -100;
OP_2 = 1000;
var rop, op1: MPInteger;
begin
z_init_set_si(rop, ROP_);
z_init_set_si(op1, OP_1);
z_addmul_ui(rop, op1, OP_2);
assert(z_get_si(rop) = ROP_ + OP_1 * OP_2);
end;
procedure TTestGmpExtensions.z_submul_test;
const
ROP_ = 10;
OP_1 = -100;
OP_2 = 1000;
var rop, op1, op2: MPInteger;
begin
z_init_set_si(rop, ROP_);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_submul(rop, op1, op2);
assert(z_get_si(rop) = ROP_ - OP_1 * OP_2);
end;
procedure TTestGmpExtensions.z_submul_ui_test;
const
ROP_ = 10;
OP_1 = -100;
OP_2 = 1000;
var rop, op1: MPInteger;
begin
z_init_set_si(rop, ROP_);
z_init_set_si(op1, OP_1);
z_submul_ui(rop, op1, OP_2);
assert(z_get_si(rop) = ROP_ - OP_1 * OP_2);
end;
procedure TTestGmpExtensions.z_mul_2exp_test;
const
OP_1 = 10;
OP_2 = 10;
var rop, op1, x: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_mul_2exp(rop, op1, OP_2);
assert(z_get_si(rop) = OP_1 * (1 shl OP_2));
x := z_mul_2exp(op1, OP_2);
assert(z_get_si(x) = OP_1 * (1 shl OP_2));
end;
procedure TTestGmpExtensions.z_neg_test;
const OP_ = 1000;
var rop, op, x: MPInteger;
begin
z_init(rop);
z_init_set_si(op, OP_);
z_neg(rop, op);
assert(z_get_si(rop) = -OP_);
x := z_neg(op);
assert(z_get_si(x) = -OP_);
end;
procedure TTestGmpExtensions.z_abs_test;
const OP_ = -1000;
var rop, op, x: MPInteger;
begin
z_init(rop);
z_init_set_si(op, OP_);
z_abs(rop, op);
assert(z_get_si(rop) = abs(OP_));
x := z_abs(op);
assert(z_get_si(x) = abs(OP_));
end;
procedure TTestGmpExtensions.z_cdiv_q_test;
const
N_ = -17;
D_ = 4;
var q, n, d, q2: MPInteger;
begin
z_init(q);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_cdiv_q(q, n, d);
assert(z_get_si(q) = ceil(N_ / D_));
q2 := z_cdiv_q(n, d);
assert(z_get_si(q2) = ceil(N_ / D_));
end;
procedure TTestGmpExtensions.z_fdiv_q_test;
const
N_ = -17;
D_ = 4;
var q, n, d, q2: MPInteger;
begin
z_init(q);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_fdiv_q(q, n, d);
assert(z_get_si(q) = floor(N_ / D_));
q2 := z_fdiv_q(n, d);
assert(z_get_si(q2) = floor(N_ / D_));
end;
procedure TTestGmpExtensions.z_tdiv_q_test;
const
N_ = -17;
D_ = 4;
var q, n, d, q2: MPInteger;
begin
z_init(q);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_tdiv_q(q, n, d);
assert(z_get_si(q) = trunc(N_ / D_));
q2 := z_tdiv_q(n, d);
assert(z_get_si(q2) = trunc(N_ / D_));
end;
procedure TTestGmpExtensions.z_cdiv_q_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var q, n, q2: MPInteger;
begin
z_init(q);
z_init_set_si(n, N_);
z_cdiv_q_2exp(q, n, B_);
assert(z_get_si(q) = ceil(N_ / D_));
q2 := z_cdiv_q_2exp(n, B_);
assert(z_get_si(q2) = ceil(N_ / D_));
end;
procedure TTestGmpExtensions.z_fdiv_q_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var q, n, q2: MPInteger;
begin
z_init(q);
z_init_set_si(n, N_);
z_fdiv_q_2exp(q, n, B_);
assert(z_get_si(q) = floor(N_ / D_));
q2 := z_fdiv_q_2exp(n, B_);
assert(z_get_si(q2) = floor(N_ / D_));
end;
procedure TTestGmpExtensions.z_tdiv_q_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var q, n, q2: MPInteger;
begin
z_init(q);
z_init_set_si(n, N_);
z_tdiv_q_2exp(q, n, B_);
assert(z_get_si(q) = trunc(N_ / D_));
q2 := z_tdiv_q_2exp(n, B_);
assert(z_get_si(q2) = trunc(N_ / D_));
end;
procedure TTestGmpExtensions.z_cdiv_q_ui_test;
const
N_ = -17;
D_ = 4;
var
q, n: MPInteger;
ur: valuint;
begin
z_init(q);
z_init_set_si(n, N_);
ur := z_cdiv_q_ui(q, n, D_);
assert(z_get_si(q) = ceil(N_ / D_));
assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
end;
procedure TTestGmpExtensions.z_fdiv_q_ui_test;
const
N_ = -17;
D_ = 4;
var
q, n: MPInteger;
ur: valuint;
begin
z_init(q);
z_init_set_si(n, N_);
ur := z_fdiv_q_ui(q, n, D_);
assert(z_get_si(q) = floor(N_ / D_));
assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
end;
procedure TTestGmpExtensions.z_tdiv_q_ui_test;
const
N_ = -17;
D_ = 4;
var
q, n: MPInteger;
ur: valuint;
begin
z_init(q);
z_init_set_si(n, N_);
ur := z_tdiv_q_ui(q, n, D_);
assert(z_get_si(q) = trunc(N_ / D_));
assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
end;
procedure TTestGmpExtensions.z_cdiv_qr_test;
const
N_ = -17;
D_ = 4;
var q, r, n, d: MPInteger;
begin
z_init(q);
z_init(r);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_cdiv_qr(q, r, n, d);
assert(z_get_si(q) = ceil(N_ / D_));
assert(z_get_si(q) * D_ + z_get_si(r) = N_);
end;
procedure TTestGmpExtensions.z_fdiv_qr_test;
const
N_ = -17;
D_ = 4;
var q, r, n, d: MPInteger;
begin
z_init(q);
z_init(r);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_fdiv_qr(q, r, n, d);
assert(z_get_si(q) = floor(N_ / D_));
assert(z_get_si(q) * D_ + z_get_si(r) = N_);
end;
procedure TTestGmpExtensions.z_tdiv_qr_test;
const
N_ = -17;
D_ = 4;
var q, r, n, d: MPInteger;
begin
z_init(q);
z_init(r);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_tdiv_qr(q, r, n, d);
assert(z_get_si(q) = trunc(N_ / D_));
assert(z_get_si(q) * D_ + z_get_si(r) = N_);
end;
procedure TTestGmpExtensions.z_cdiv_qr_ui_test;
const
N_ = -17;
D_ = 4;
var
q, r, n: MPInteger;
ur: valuint;
begin
z_init(q);
z_init(r);
z_init_set_si(n, N_);
ur := z_cdiv_qr_ui(q, r, n, D_);
assert(z_get_si(q) = ceil(N_ / D_));
assert(z_get_si(q) * D_ + z_get_si(r) = N_);
assert(ur - abs(z_get_si(r)) = 0);
end;
procedure TTestGmpExtensions.z_fdiv_qr_ui_test;
const
N_ = -17;
D_ = 4;
var
q, r, n: MPInteger;
ur: valuint;
begin
z_init(q);
z_init(r);
z_init_set_si(n, N_);
ur := z_fdiv_qr_ui(q, r, n, D_);
assert(z_get_si(q) = floor(N_ / D_));
assert(z_get_si(q) * D_ + z_get_si(r) = N_);
assert(ur - abs(z_get_si(r)) = 0);
end;
procedure TTestGmpExtensions.z_tdiv_qr_ui_test;
const
N_ = -17;
D_ = 4;
var
q, r, n: MPInteger;
ur: valuint;
begin
z_init(q);
z_init(r);
z_init_set_si(n, N_);
ur := z_tdiv_qr_ui(q, r, n, D_);
assert(z_get_si(q) = trunc(N_ / D_));
assert(z_get_si(q) * D_ + z_get_si(r) = N_);
assert(ur - abs(z_get_si(r)) = 0);
end;
procedure TTestGmpExtensions.z_cdiv_r_test;
const
N_ = -17;
D_ = 4;
var r, n, d, r2: MPInteger;
begin
z_init(r);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_cdiv_r(r, n, d);
assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
r2 := z_cdiv_r(n, d);
assert(ceil(N_ / D_) * D_ + z_get_si(r2) = N_);
end;
procedure TTestGmpExtensions.z_fdiv_r_test;
const
N_ = -17;
D_ = 4;
var r, n, d, r2: MPInteger;
begin
z_init(r);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_fdiv_r(r, n, d);
assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
r2 := z_fdiv_r(n, d);
assert(floor(N_ / D_) * D_ + z_get_si(r2) = N_);
end;
procedure TTestGmpExtensions.z_tdiv_r_test;
const
N_ = -17;
D_ = 4;
var r, n, d, r2: MPInteger;
begin
z_init(r);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_tdiv_r(r, n, d);
assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
r2 := z_tdiv_r(n, d);
assert(trunc(N_ / D_) * D_ + z_get_si(r2) = N_);
end;
procedure TTestGmpExtensions.z_cdiv_r_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var r, n, r2: MPInteger;
begin
z_init(r);
z_init_set_si(n, N_);
z_cdiv_r_2exp(r, n, B_);
assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
r2 := z_cdiv_r_2exp(n, B_);
assert(ceil(N_ / D_) * D_ + z_get_si(r2) = N_);
end;
procedure TTestGmpExtensions.z_fdiv_r_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var r, n, r2: MPInteger;
begin
z_init(r);
z_init_set_si(n, N_);
z_fdiv_r_2exp(r, n, B_);
assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
r2 := z_fdiv_r_2exp(n, B_);
assert(floor(N_ / D_) * D_ + z_get_si(r2) = N_);
end;
procedure TTestGmpExtensions.z_tdiv_r_2exp_test;
const
N_ = -17;
B_ = 2;
D_ = 1 shl B_;
var r, n, r2: MPInteger;
begin
z_init(r);
z_init_set_si(n, N_);
z_tdiv_r_2exp(r, n, B_);
assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
r2 := z_tdiv_r_2exp(n, B_);
assert(trunc(N_ / D_) * D_ + z_get_si(r2) = N_);
end;
procedure TTestGmpExtensions.z_cdiv_r_ui_test;
const
N_ = -17;
D_ = 4;
var
r, n: MPInteger;
ur: valuint;
begin
z_init(r);
z_init_set_si(n, N_);
ur := z_cdiv_r_ui(r, n, D_);
assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
assert(ur - abs(z_get_si(r)) = 0);
end;
procedure TTestGmpExtensions.z_fdiv_r_ui_test;
const
N_ = -17;
D_ = 4;
var
r, n: MPInteger;
ur: valuint;
begin
z_init(r);
z_init_set_si(n, N_);
ur := z_fdiv_r_ui(r, n, D_);
assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
assert(ur - abs(z_get_si(r)) = 0);
end;
procedure TTestGmpExtensions.z_tdiv_r_ui_test;
const
N_ = -17;
D_ = 4;
var
r, n: MPInteger;
ur: valuint;
begin
z_init(r);
z_init_set_si(n, N_);
ur := z_tdiv_r_ui(r, n, D_);
assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
assert(ur - abs(z_get_si(r)) = 0);
end;
procedure TTestGmpExtensions.z_cdiv_ui_test;
const
N_ = -17;
D_ = 4;
var n: MPInteger;
begin
z_init_set_si(n, N_);
assert(z_cdiv_ui(n, D_) - abs(N_ - ceil(N_ / D_) * D_) = 0);
end;
procedure TTestGmpExtensions.z_fdiv_ui_test;
const
N_ = -17;
D_ = 4;
var n: MPInteger;
begin
z_init_set_si(n, N_);
assert(z_fdiv_ui(n, D_) - abs(N_ - floor(N_ / D_) * D_) = 0);
end;
procedure TTestGmpExtensions.z_tdiv_ui_test;
const
N_ = -17;
D_ = 4;
var n: MPInteger;
begin
z_init_set_si(n, N_);
assert(z_tdiv_ui(n, D_) = abs(N_ - trunc(N_ / D_) * D_));
end;
procedure TTestGmpExtensions.z_mod_test;
const
N_ = 17;
D_ = -4;
var r, n, d, r2: MPInteger;
begin
z_init(r);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_mod(r, n, d);
assert(z_get_si(r) = N_ mod abs(D_));
r2 := z_mod(n, d);
assert(z_get_si(r2) = N_ mod abs(D_));
end;
procedure TTestGmpExtensions.z_divexact_test;
const
N_ = -16;
D_ = 4;
var q, n, d, q2: MPInteger;
begin
z_init(q);
z_init_set_si(n, N_);
z_init_set_si(d, D_);
z_divexact(q, n, d);
assert(z_get_si(q) * D_ = N_);
q2 := z_divexact(n, d);
assert(z_get_si(q2) * D_ = N_);
end;
procedure TTestGmpExtensions.z_divexact_ui_test;
const
N_ = -16;
D_ = 4;
var q, n, q2: MPInteger;
begin
z_init(q);
z_init_set_si(n, N_);
z_divexact_ui(q, n, D_);
assert(z_get_si(q) * D_ = N_);
q2 := z_divexact_ui(n, D_);
assert(z_get_si(q2) * D_ = N_);
end;
procedure TTestGmpExtensions.z_divisible_p_test;
const
N_ = -16;
D_ = 4;
var n, d: MPInteger;
begin
z_init_set_si(n, N_);
z_init_set_si(d, D_);
assert(z_divisible_p(n, d));
z_set_si(n, z_get_si(n) + 1);
assert(not z_divisible_p(n, d));
end;
procedure TTestGmpExtensions.z_divisible_ui_p_test;
const
N_ = -16;
D_ = 4;
var n: MPInteger;
begin
z_init_set_si(n, N_);
assert(z_divisible_ui_p(n, D_));
z_set_si(n, z_get_si(n) + 1);
assert(not z_divisible_ui_p(n, D_));
end;
procedure TTestGmpExtensions.z_divisible_2exp_p_test;
const
N_ = -16;
B_ = 2;
var n: MPInteger;
begin
z_init_set_si(n, N_);
assert(z_divisible_2exp_p(n, B_));
z_set_si(n, z_get_si(n) + 1);
assert(not z_divisible_ui_p(n, B_));
end;
procedure TTestGmpExtensions.z_congruent_p_test;
const
N_ = 23;
C_ = 6;
D_ = 17;
var n, c, d: MPInteger;
begin
z_init_set_si(n, N_);
z_init_set_si(c, C_);
z_init_set_si(d, D_);
assert(z_congruent_p(n, c, d));
z_set_si(n, z_get_si(n) + 1);
assert(not z_congruent_p(n, c, d));
end;
procedure TTestGmpExtensions.z_congruent_2exp_p_test;
const
N_ = 23;
C_ = 7;
B_ = 4;
var n, c: MPInteger;
begin
z_init_set_si(n, N_);
z_init_set_si(c, C_);
assert(z_congruent_2exp_p(n, c, B_));
z_set_si(n, z_get_si(n) + 1);
assert(not z_congruent_2exp_p(n, c, B_));
end;
procedure TTestGmpExtensions.z_congruent_ui_p_test;
const
N_ = 23;
C_ = 6;
D_ = 17;
var n: MPInteger;
begin
z_init_set_si(n, N_);
assert(z_congruent_ui_p(n, C_, D_));
z_set_si(n, z_get_si(n) + 1);
assert(not z_congruent_ui_p(n, C_, D_));
end;
procedure TTestGmpExtensions.z_powm_test;
const
N_EXP = 3;
N_MOD = 16;
ROP_ = 8;
var rop, base, exp, mod_, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(base, BASE10);
z_init_set_si(exp, N_EXP);
z_init_set_si(mod_, N_MOD);
z_powm(rop, base, exp, mod_);
assert(z_get_si(rop) = ROP_);
r2 := z_powm(base, exp, mod_);
assert(z_get_si(r2) = ROP_);
end;
procedure TTestGmpExtensions.z_powm_ui_test;
const
N_EXP = 3;
N_MOD = 16;
ROP_ = 8;
var rop, base, mod_, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(base, BASE10);
z_init_set_si(mod_, N_MOD);
z_powm_ui(rop, base, N_EXP, mod_);
assert(z_get_si(rop) = ROP_);
r2 := z_powm_ui(base, N_EXP, mod_);
assert(z_get_si(r2) = ROP_);
end;
procedure TTestGmpExtensions.z_pow_ui_test;
const
BASE_ = 10;
EXP = 3;
var rop, base, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(base, BASE_);
z_pow_ui(rop, base, EXP);
assert(z_get_si(rop) = BASE_ ** EXP);
r2 := z_pow_ui(base, EXP);
assert(z_get_si(r2) = BASE_ ** EXP);
end;
procedure TTestGmpExtensions.z_ui_pow_ui_test;
const
BASE_ = 10;
EXP = 3;
var rop, r2: MPInteger;
begin
z_init(rop);
z_ui_pow_ui(rop, BASE_, EXP);
assert(z_get_si(rop) = BASE_ ** EXP);
r2 := z_ui_pow_ui(BASE_, EXP);
assert(z_get_si(r2) = BASE_ ** EXP);
end;
procedure TTestGmpExtensions.z_root_test;
const
ROOT = 5;
N_ = 3;
var rop, op: MPInteger;
begin
z_init(rop);
z_init_set_si(op, ROOT ** N_);
assert(z_root(rop, op, N_));
assert(z_get_si(rop) = ROOT);
z_set_si(op, ROOT ** N_ + 1);
assert(not z_root(rop, op, N_));
assert(z_get_si(rop) = ROOT);
end;
procedure TTestGmpExtensions.z_rootrem_test;
const
ROOT_ = 5;
N_ = 3;
REM_ = 1;
var root, rem, u: MPInteger;
begin
assert(REM_ < ROOT_);
z_init(root);
z_init(rem);
z_init_set_si(u, ROOT_ ** N_);
z_rootrem(root, rem, u, N_);
assert(z_get_si(root) = ROOT_);
assert(z_get_si(rem) = 0);
z_set_si(u, ROOT_ ** N_ + REM_);
z_rootrem(root, rem, u, N_);
assert(z_get_si(root) = ROOT_);
assert(z_get_si(rem) = REM_);
end;
procedure TTestGmpExtensions.z_sqrt_test;
const ROOT = 5;
var rop, op, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op, ROOT ** 2);
z_sqrt(rop, op);
assert(z_get_si(rop) = ROOT);
r2 := z_sqrt(op);
assert(z_get_si(r2) = ROOT);
end;
procedure TTestGmpExtensions.z_sqrtrem_test;
const
ROOT = 5;
REM = 1;
var rop1, rop2, op: MPInteger;
begin
z_init(rop1);
z_init(rop2);
z_init_set_si(op, ROOT ** 2 + REM);
z_sqrtrem(rop1, rop2, op);
assert(z_get_si(rop1) = ROOT);
assert(z_get_si(rop2) = REM);
end;
procedure TTestGmpExtensions.z_perfect_power_p_test;
const
ROOT = 3;
EXP = 3;
var op: MPInteger;
begin
z_init_set_si(op, ROOT ** EXP);
assert(z_perfect_power_p(op));
z_set_si(op, ROOT ** EXP + 1);
assert(not z_perfect_power_p(op));
end;
procedure TTestGmpExtensions.z_perfect_square_p_test;
const ROOT = 3;
var op: MPInteger;
begin
z_init_set_si(op, ROOT ** 2);
assert(z_perfect_square_p(op));
z_set_si(op, ROOT ** 2 or 2);
assert(not z_perfect_square_p(op));
end;
procedure TTestGmpExtensions.z_probab_prime_p_test;
const
N_ = 127;
REPS = 5;
var n: MPInteger;
begin
z_init_set_si(n, N_);
assert(z_probab_prime_p(n, REPS) = 2);
z_set_si(n, N_ + 1);
assert(z_probab_prime_p(n, REPS) = 0);
end;
procedure TTestGmpExtensions.z_nextprime_test;
const
PRIME3 = 5;
PRIME4 = 7;
var rop, op, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op, PRIME3);
z_nextprime(rop, op);
assert(z_get_si(rop) = PRIME4);
r2 := z_nextprime(op);
assert(z_get_si(r2) = PRIME4);
end;
procedure TTestGmpExtensions.z_gcd_test;
const
OP_1 = 42;
OP_2 = 56;
ROP_ = 14;
var rop, op1, op2, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_gcd(rop, op1, op2);
assert(z_get_si(rop) = ROP_);
r2 := z_gcd(op1, op2);
assert(z_get_si(r2) = ROP_);
end;
procedure TTestGmpExtensions.z_gcd_ui_test;
const
OP_1 = 42;
OP_2 = 56;
ROP_ = 14;
var rop, op1: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
assert(z_gcd_ui(rop, op1, OP_2) = ROP_);
assert(z_get_si(rop) = ROP_);
end;
procedure TTestGmpExtensions.z_gcdext_test;
const
A_ = 42;
B_ = 56;
G_ = 14;
var g, s, t, a, b: MPInteger;
begin
z_init(g);
z_init(s);
z_init(t);
z_init_set_si(a, A_);
z_init_set_si(b, B_);
z_gcdext(g, s, t, a, b);
assert(z_get_si(g) = G_);
assert(A_ * z_get_si(s) + B_ * z_get_si(t) = G_);
end;
procedure TTestGmpExtensions.z_lcm_test;
const
OP_1 = 21;
OP_2 = 6;
ROP_ = 42;
var rop, op1, op2, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_lcm(rop, op1, op2);
assert(z_get_si(rop) = ROP_);
r2 := z_lcm(op1, op2);
assert(z_get_si(r2) = ROP_);
end;
procedure TTestGmpExtensions.z_lcm_ui_test;
const
OP_1 = 21;
OP_2 = 6;
ROP_ = 42;
var rop, op1, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_lcm_ui(rop, op1, OP_2);
assert(z_get_si(rop) = ROP_);
r2 := z_lcm_ui(op1, OP_2);
assert(z_get_si(r2) = ROP_);
end;
procedure TTestGmpExtensions.z_invert_test;
const
OP_1 = 256;
OP_2 = 337;
ROP_ = 104;
var rop, op1, op2: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
assert(z_invert(rop, op1, op2) <> 0);
assert(z_get_si(rop) = ROP_);
end;
procedure TTestGmpExtensions.z_jacobi_test;
const
B0 = 11;
A0 = 13 * B0;
AM1 = 1001;
BM1 = 9907;
A1 = 4;
B1 = 7;
var a, b: MPInteger;
begin
z_init_set_si(a, A0);
z_init_set_si(b, B0);
assert(z_jacobi(a, b) = 0);
z_set_si(a, AM1);
z_set_si(b, BM1);
assert(z_jacobi(a, b) = -1);
z_set_si(a, A1);
z_set_si(b, B1);
assert(z_jacobi(a, b) = 1);
end;
procedure TTestGmpExtensions.z_kronecker_si_test;
const
A_ = 8;
B0 = 6;
BM1 = 5;
B1 = 7;
var a: MPInteger;
begin
z_init_set_si(a, A_);
assert(z_kronecker_si(a, B1) = 1);
assert(z_kronecker_si(a, B0) = 0);
assert(z_kronecker_si(a, BM1) = -1);
end;
procedure TTestGmpExtensions.z_kronecker_ui_test;
const
A_ = 8;
B0 = 6;
BM1 = 5;
B1 = 7;
var a: MPInteger;
begin
z_init_set_si(a, A_);
assert(z_kronecker_ui(a, B1) = 1);
assert(z_kronecker_ui(a, B0) = 0);
assert(z_kronecker_ui(a, BM1) = -1);
end;
procedure TTestGmpExtensions.z_si_kronecker_test;
const
A_ = 8;
B0 = 6;
BM1 = 5;
B1 = 7;
var b: MPInteger;
begin
z_init_set_si(b, B1);
assert(z_si_kronecker(A_, b) = 1);
z_set_si(b, B0);
assert(z_si_kronecker(A_, b) = 0);
z_set_si(b, BM1);
assert(z_si_kronecker(A_, b) = -1);
end;
procedure TTestGmpExtensions.z_ui_kronecker_test;
const
A_ = 8;
B0 = 6;
BM1 = 5;
B1 = 7;
var b: MPInteger;
begin
z_init_set_si(b, B1);
assert(z_ui_kronecker(A_, b) = 1);
z_set_si(b, B0);
assert(z_ui_kronecker(A_, b) = 0);
z_set_si(b, BM1);
assert(z_ui_kronecker(A_, b) = -1);
end;
procedure TTestGmpExtensions.z_remove_test;
const
F_ = 5;
OP_ = 3 * F_ * 7;
ROP_ = OP_ div F_;
var rop, op, f: MPInteger;
begin
z_init(rop);
z_init_set_si(op, OP_);
z_init_set_si(f, F_);
assert(z_remove(rop, op, f) = 1);
assert(z_get_si(rop) = ROP_);
end;
procedure TTestGmpExtensions.z_fac_ui_test;
const
OP = 4;
ROP_ = 2 * 3 * 4;
var rop, r2: MPInteger;
begin
z_init(rop);
z_fac_ui(rop, OP);
assert(z_get_si(rop) = ROP_);
r2 := z_fac_ui(OP);
assert(z_get_si(r2) = ROP_);
end;
procedure TTestGmpExtensions.z_bin_ui_test;
const
N_ = 7;
K = 3;
ROP_ = 35;
var rop, n, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(n, N_);
z_bin_ui(rop, n, K);
assert(z_get_si(rop) = ROP_);
r2 := z_bin_ui(n, K);
assert(z_get_si(r2) = ROP_);
end;
procedure TTestGmpExtensions.z_bin_uiui_test;
const
N = 7;
K = 3;
ROP_ = 35;
var rop, r2: MPInteger;
begin
z_init(rop);
z_bin_uiui(rop, N, K);
assert(z_get_si(rop) = ROP_);
r2 := z_bin_uiui(N, K);
assert(z_get_si(r2) = ROP_);
end;
procedure TTestGmpExtensions.z_fib_ui_test;
const
N = 10;
FN_ = 55;
var fn, ff: MPInteger;
begin
z_init(fn);
z_fib_ui(fn, N);
assert(z_get_si(fn) = FN_);
ff := z_fib_ui(N);
assert(z_get_si(ff) = FN_);
end;
procedure TTestGmpExtensions.z_fib2_ui_test;
const
N = 10;
FN_ = 55;
FNSUB1_ = 34;
var fn, fnsub1, ff, ff1: MPInteger;
begin
z_init(fn);
z_init(fnsub1);
z_fib2_ui(fn, fnsub1, N);
assert(z_get_si(fn) = FN_);
assert(z_get_si(fnsub1) = FNSUB1_);
z_init(ff1);
ff := z_fib2_ui(ff1, N);
assert(z_get_si(ff) = FN_);
assert(z_get_si(ff1) = FNSUB1_);
end;
procedure TTestGmpExtensions.z_lucnum_ui_test;
const
N = 10;
LN_ = 123;
var ln, l2: MPInteger;
begin
z_init(ln);
z_lucnum_ui(ln, N);
assert(z_get_si(ln) = LN_);
l2 := z_lucnum_ui(N);
assert(z_get_si(l2) = LN_);
end;
procedure TTestGmpExtensions.z_lucnum2_ui_test;
const
N = 10;
LN_ = 123;
LNSUB1_ = 76;
var ln, lnsub1, l2, l2s1: MPInteger;
begin
z_init(ln);
z_init(lnsub1);
z_lucnum2_ui(ln, lnsub1, N);
assert(z_get_si(ln) = LN_);
assert(z_get_si(lnsub1) = LNSUB1_);
z_init(l2s1);
l2 := z_lucnum2_ui(l2s1, N);
assert(z_get_si(l2) = LN_);
assert(z_get_si(l2s1) = LNSUB1_);
end;
procedure TTestGmpExtensions.z_cmp_test;
const
OP_1 = -10;
OP_2 = OP_1 - 1;
var op1, op2: MPInteger;
begin
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
assert(z_cmp(op1, op2) > 0);
z_set_si(op2, OP_1);
assert(z_cmp(op1, op2) = 0);
z_set_si(op2, OP_1 + 1);
assert(z_cmp(op1, op2) < 0);
end;
procedure TTestGmpExtensions.z_cmp_d_test;
const
OP_1 = -10;
var op1: MPInteger;
begin
z_init_set_si(op1, OP_1);
assert(z_cmp_d(op1, OP_1 - 1) > 0);
assert(z_cmp_d(op1, OP_1) = 0);
assert(z_cmp_d(op1, OP_1 + 1) < 0);
end;
procedure TTestGmpExtensions.z_cmp_si_test;
const
OP_1 = -10;
var op1: MPInteger;
begin
z_init_set_si(op1, OP_1);
assert(z_cmp_si(op1, OP_1 - 1) > 0);
assert(z_cmp_si(op1, OP_1) = 0);
assert(z_cmp_si(op1, OP_1 + 1) < 0);
end;
procedure TTestGmpExtensions.z_cmp_ui_test;
const
OP_1 = 10;
var op1: MPInteger;
begin
z_init_set_si(op1, OP_1);
assert(z_cmp_ui(op1, OP_1 - 1) > 0);
assert(z_cmp_ui(op1, OP_1) = 0);
assert(z_cmp_ui(op1, OP_1 + 1) < 0);
end;
procedure TTestGmpExtensions.z_cmpabs_test;
const
OP_1 = -10;
OP_2 = -OP_1 - 1;
var op1, op2: MPInteger;
begin
z_init_set_si(op1, OP_1);
z_init_set_si(op2, -OP_2);
assert(z_cmpabs(op1, op2) > 0);
z_set_si(op2, -OP_1);
assert(z_cmpabs(op1, op2) = 0);
z_set_si(op2, -OP_1 + 1);
assert(z_cmpabs(op1, op2) < 0);
end;
procedure TTestGmpExtensions.z_cmpabs_d_test;
const OP_1 = -10;
var op1: MPInteger;
begin
z_init_set_si(op1, OP_1);
assert(z_cmpabs_d(op1, -OP_1 - 1) > 0);
assert(z_cmpabs_d(op1, -OP_1) = 0);
assert(z_cmpabs_d(op1, -OP_1 + 1) < 0);
end;
procedure TTestGmpExtensions.z_cmpabs_ui_test;
const OP_1 = -10;
var op1: MPInteger;
begin
z_init_set_si(op1, OP_1);
assert(z_cmpabs_ui(op1, -OP_1 - 1) > 0);
assert(z_cmpabs_ui(op1, -OP_1) = 0);
assert(z_cmpabs_ui(op1, -OP_1 + 1) < 0);
end;
procedure TTestGmpExtensions.z_and_test;
const
OP_1 = $c;
OP_2 = $a;
var rop, op1, op2, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_and(rop, op1, op2);
assert(z_get_si(rop) = OP_1 and OP_2);
r2 := z_and(op1, op2);
assert(z_get_si(r2) = OP_1 and OP_2);
end;
procedure TTestGmpExtensions.z_ior_test;
const
OP_1 = $c;
OP_2 = $a;
var rop, op1, op2, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_ior(rop, op1, op2);
assert(z_get_si(rop) = OP_1 or OP_2);
r2 := z_ior(op1, op2);
assert(z_get_si(r2) = OP_1 or OP_2);
end;
procedure TTestGmpExtensions.z_xor_test;
const
OP_1 = $c;
OP_2 = $a;
var rop, op1, op2, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
z_xor(rop, op1, op2);
assert(z_get_si(rop) = OP_1 xor OP_2);
r2 := z_xor(op1, op2);
assert(z_get_si(r2) = OP_1 xor OP_2);
end;
procedure TTestGmpExtensions.z_com_test;
const
OP_1 = 2;
var rop, op1, r2: MPInteger;
begin
z_init(rop);
z_init_set_si(op1, OP_1);
z_com(rop, op1);
assert(z_get_si(rop) = not OP_1 );
r2 := z_com(op1);
assert(z_get_si(r2) = not OP_1 );
end;
procedure TTestGmpExtensions.z_popcount_test;
const
OP_ = $55AA;
N = 8;
var op: MPInteger;
begin
z_init_set_si(op, OP_);
assert(z_popcount(op) = N);
end;
procedure TTestGmpExtensions.z_hamdist_test;
const
OP_1 = $55;
OP_2 = $7A;
N = 5;
var op1, op2: MPInteger;
begin
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
assert(z_hamdist(op1, op2) = N);
end;
procedure TTestGmpExtensions.z_scan0_test;
const
OP_ = $F75;
STARTING_BIT = 4;
N = 7;
var op: MPInteger;
begin
z_init_set_si(op, OP_);
assert(z_scan0(op, STARTING_BIT) = N);
end;
procedure TTestGmpExtensions.z_scan1_test;
const
OP_ = $85;
STARTING_BIT = 4;
N = 7;
var op: MPInteger;
begin
z_init_set_si(op, OP_);
assert(z_scan1(op, STARTING_BIT) = N);
end;
procedure TTestGmpExtensions.z_setbit_test;
const
ROP_ = $F75;
BIT_INDEX = 7;
var rop: MPInteger;
begin
z_init_set_ui(rop, ROP_);
z_setbit(rop, BIT_INDEX);
assert(z_get_ui(rop) = ROP_ or (1 shl BIT_INDEX));
end;
procedure TTestGmpExtensions.z_clrbit_test;
const
ROP_ = $F75;
BIT_INDEX = 9;
var rop: MPInteger;
begin
z_init_set_ui(rop, ROP_);
z_clrbit(rop, BIT_INDEX);
assert(z_get_ui(rop) = ROP_ and not (1 shl BIT_INDEX));
end;
procedure TTestGmpExtensions.z_combit_test;
const
ROP_ = $F75;
BIT_INDEX = 7;
var rop: MPInteger;
begin
z_init_set_ui(rop, ROP_);
z_combit(rop, BIT_INDEX);
assert(z_get_ui(rop) = ROP_ xor (1 shl BIT_INDEX));
end;
procedure TTestGmpExtensions.z_tstbit_test;
const
ROP_ = $F75;
BIT_INDEX1 = 7;
BIT_INDEX2 = 8;
var rop: MPInteger;
begin
z_init_set_ui(rop, ROP_);
assert(z_tstbit(rop, BIT_INDEX1) = longbool(ROP_ and (1 shl BIT_INDEX1)));
assert(z_tstbit(rop, BIT_INDEX2) = longbool(ROP_ and (1 shl BIT_INDEX2)));
end;
procedure TTestGmpExtensions.z_urandomb_test;
const
B = 8 * (sizeof(valuint) - 1);
N = 1 shl B;
var
rop, r2: MPInteger;
state: MPRandState;
begin
randinit_default(state);
z_init(rop);
z_urandomb(rop, state, B);
assert(z_cmp_ui(rop, N) < 0);
r2 := z_urandomb(state, B);
assert(z_cmp_ui(r2, N) < 0);
end;
procedure TTestGmpExtensions.z_urandomm_test;
const
N_ = 1000000;
var
rop, n, r2: MPInteger;
state: MPRandState;
begin
randinit_default(state);
z_init(rop);
z_init_set_ui(n, N_);
z_urandomm(rop, state, n);
assert(z_cmp_ui(rop, N_) < 0);
r2 := z_urandomm(state, n);
assert(z_cmp_ui(r2, N_) < 0);
end;
procedure TTestGmpExtensions.z_rrandomb_test;
const
B = 8 * sizeof(valuint) - 2;
N = 1 shl B;
var
rop, r2: MPInteger;
state: MPRandState;
begin
randinit_default(state);
z_init(rop);
z_rrandomb(rop, state, B);
assert(z_cmp_ui(rop, N) < 0);
r2 := z_rrandomb(state, B);
assert(z_cmp_ui(r2, N) < 0);
end;
procedure TTestGmpExtensions.z_fits_ushort_p_test;
var op: MPInteger;
begin
z_init_set_ui(op, high(word));
assert(z_fits_ushort_p(op));
z_add_ui(op, op, 1);
assert(not z_fits_ushort_p(op));
end;
procedure TTestGmpExtensions.z_fits_sshort_p_test;
var op: MPInteger;
begin
z_init_set_si(op, high(smallint));
assert(z_fits_sshort_p(op));
z_add_ui(op, op, 1);
assert(not z_fits_sshort_p(op));
end;
procedure TTestGmpExtensions.z_fits_uint_p_test;
var op: MPInteger;
begin
z_init_set_ui(op, high(cardinal));
assert(z_fits_uint_p(op));
z_add_ui(op, op, 1);
assert(not z_fits_uint_p(op));
end;
procedure TTestGmpExtensions.z_fits_sint_p_test;
var op: MPInteger;
begin
z_init_set_si(op, high(integer));
assert(z_fits_sint_p(op));
z_add_ui(op, op, 1);
assert(not z_fits_sint_p(op));
end;
procedure TTestGmpExtensions.z_fits_ulong_p_test;
var op: MPInteger;
begin
z_init_set_ui(op, high(valuint));
assert(z_fits_ulong_p(op));
z_add_ui(op, op, 1);
assert(not z_fits_ulong_p(op));
end;
procedure TTestGmpExtensions.z_fits_slong_p_test;
var op: MPInteger;
begin
z_init_set_si(op, high(valsint));
assert(z_fits_slong_p(op));
z_add_ui(op, op, 1);
assert(not z_fits_slong_p(op));
end;
procedure TTestGmpExtensions.z_sizeinbase_test;
const
OP_ = 1000000;
var rop: MPInteger;
begin
z_init_set_ui(rop, OP_);
assert(z_sizeinbase(rop, BASE10) - length(inttostr(OP_)) = 0);
end;
procedure TTestGmpExtensions.z_size_test;
var rop: MPInteger;
begin
z_init(rop);
assert(z_size(rop) = 0);
z_add_ui(rop, rop, 1);
assert(z_size(rop) = 1);
end;
procedure TTestGmpExtensions.q_init_test;
var rational: MPRational;
begin
q_init(rational);
assert(q_cmp_ui(rational, 0, 1) = 0);
end;
procedure TTestGmpExtensions.q_clear_test;
var rational: MPRational;
begin
q_init(rational);
q_clear(rational);
end;
procedure TTestGmpExtensions.q_set_ui_test;
const
OP_1 = 13;
OP_2 = 17;
var rational: MPRational;
begin
q_init(rational);
q_set_ui(rational, OP_1, OP_2);
assert(q_cmp_ui(rational, OP_1, OP_2) = 0);
end;
procedure TTestGmpExtensions.q_set_si_test;
const
OP_1 = -13;
OP_2 = 17;
var rational: MPRational;
begin
q_init(rational);
q_set_si(rational, OP_1, OP_2);
assert(q_cmp_si(rational, OP_1, OP_2) = 0);
end;
procedure TTestGmpExtensions.q_canonicalize_test;
const
OP_1 = -13;
OP_2 = 17;
CF = 11;
var rational: MPRational;
begin
q_init(rational);
q_set_si(rational, CF * OP_1, CF * OP_2);
q_canonicalize(rational);
assert(q_cmp_si(rational, OP_1, OP_2) = 0);
end;
procedure TTestGmpExtensions.q_set_test;
const
OP_1 = -13;
OP_2 = 17;
var rational1, rational2: MPRational;
begin
q_init(rational1);
q_init(rational2);
q_set_si(rational2, OP_1, OP_2);
q_set(rational1, rational2);
assert(q_cmp_si(rational1, OP_1, OP_2) = 0);
end;
procedure TTestGmpExtensions.q_set_z_test;
const
OP_1 = -13;
var
rational: MPRational;
op: MPInteger;
begin
q_init(rational);
z_init_set_si(op, OP_1);
q_set_z(rational, op);
assert(q_cmp_si(rational, OP_1, 1) = 0);
end;
procedure TTestGmpExtensions.q_set_str_test;
const
OP_1 = -13;
OP_2 = 17;
var rational: MPRational;
begin
q_init(rational);
assert(q_set_str(rational, pchar(inttostr(OP_1) + '/' + inttostr(OP_2)), BASE10));
assert(q_cmp_si(rational, OP_1, OP_2) = 0);
assert(not q_set_str(rational, pchar(inttostr(OP_1) + '*' + inttostr(OP_2)), BASE10));
end;
procedure TTestGmpExtensions.q_swap_test;
const
ROP_1N = -13;
ROP_1D = 17;
ROP_2N = -23;
ROP_2D = 31;
var rop1, rop2: MPRational;
begin
q_init(rop1);
q_init(rop2);
q_set_si(rop1, ROP_1N, ROP_1D);
q_set_si(rop2, ROP_2N, ROP_2D);
q_swap(rop1, rop2);
assert(q_cmp_si(rop1, ROP_2N, ROP_2D) = 0);
assert(q_cmp_si(rop2, ROP_1N, ROP_1D) = 0);
end;
procedure TTestGmpExtensions.q_get_d_test;
const
OP_1 = -1;
OP_2 = 2;
var op: MPRational;
begin
q_init(op);
q_set_si(op, OP_1, OP_2);
assert(q_get_d(op) = OP_1 / OP_2);
end;
procedure TTestGmpExtensions.q_set_d_test;
const
OP_1 = -1;
OP_2 = 2;
var rop: MPRational;
begin
q_init(rop);
q_set_d(rop, OP_1 / OP_2);
assert(q_cmp_si(rop, OP_1, OP_2) = 0);
end;
procedure TTestGmpExtensions.q_set_f_test;
const OP_ = -10;
var
op: MPFloat;
rop: MPRational;
begin
f_init_set_si(op, OP_);
q_init(rop);
q_set_f(rop, op);
assert(q_get_d(rop) = OP_);
end;
procedure TTestGmpExtensions.q_get_str_test;
const
OP_1 = -1;
OP_2 = 2;
var
op: MPRational;
p: pchar;
s, s2: string;
begin
q_init(op);
q_set_si(op, OP_1, OP_2);
s := q_get_str(BASE10, op);
assert(s = inttostr(OP_1) + '/' + inttostr(OP_2));
p := q_get_str(nil, BASE10, op);
assert(p = inttostr(OP_1) + '/' + inttostr(OP_2));
freemem(p);
setlength(s2, length(inttostr(OP_1) + '/' + inttostr(OP_2)));
assert(pointer(q_get_str(pchar(s2), BASE10, op)) = pointer(s2));
assert(s2 = inttostr(OP_1) + '/' + inttostr(OP_2));
end;
procedure TTestGmpExtensions.q_add_test;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var sum, addend1, addend2, s2: MPRational;
begin
q_init(sum);
q_init(addend1);
q_init(addend2);
q_set_si(addend1, N1, D1);
q_set_si(addend2, N2, D2);
q_add(sum, addend1, addend2);
assert(q_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
s2 := q_add(addend1, addend2);
assert(q_cmp_si(s2, N1 * D2 + N2 * D1, D1 * D2) = 0);
end;
procedure TTestGmpExtensions.q_sub_test;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var difference, minuend, subtrahend, diff2: MPRational;
begin
q_init(difference);
q_init(minuend);
q_init(subtrahend);
q_set_si(minuend, N1, D1);
q_set_si(subtrahend, N2, D2);
q_sub(difference, minuend, subtrahend);
assert(q_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
diff2 := q_sub(minuend, subtrahend);
assert(q_cmp_si(diff2, N1 * D2 - N2 * D1, D1 * D2) = 0);
end;
procedure TTestGmpExtensions.q_mul_test;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var product, multiplier, multiplicant, p2: MPRational;
begin
q_init(product);
q_init(multiplier);
q_init(multiplicant);
q_set_si(multiplier, N1, D1);
q_set_si(multiplicant, N2, D2);
q_mul(product, multiplier, multiplicant);
assert(q_cmp_si(product, N1 * N2, D1 * D2) = 0);
p2 := q_mul(multiplier, multiplicant);
assert(q_cmp_si(p2, N1 * N2, D1 * D2) = 0);
end;
procedure TTestGmpExtensions.q_mul_2exp_test;
const
N1 = 5;
D1 = 3;
OP_2 = 2;
var rop, op1, r2: MPRational;
begin
q_init(rop);
q_init(op1);
q_set_si(op1, N1, D1);
q_mul_2exp(rop, op1, OP_2);
assert(q_cmp_si(rop, N1 * (1 shl OP_2), D1) = 0);
r2 := q_mul_2exp(op1, OP_2);
assert(q_cmp_si(r2, N1 * (1 shl OP_2), D1) = 0);
end;
procedure TTestGmpExtensions.q_div_test;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var quotient, dividend, divisor, q2: MPRational;
begin
q_init(quotient);
q_init(dividend);
q_init(divisor);
q_set_si(dividend, N1, D1);
q_set_si(divisor, N2, D2);
q_div(quotient, dividend, divisor);
assert(q_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
q2 := q_div(dividend, divisor);
assert(q_cmp_si(q2, -N1 * D2, -D1 * N2) = 0);
end;
procedure TTestGmpExtensions.q_div_2exp_test;
const
N1 = 5;
D1 = 3;
OP_2 = 2;
var rop, op1, r2: MPRational;
begin
q_init(rop);
q_init(op1);
q_set_si(op1, N1, D1);
q_div_2exp(rop, op1, OP_2);
assert(q_cmp_si(rop, N1, D1 * (1 shl OP_2)) = 0);
r2 := q_div_2exp(op1, OP_2);
assert(q_cmp_si(r2, N1, D1 * (1 shl OP_2)) = 0);
end;
procedure TTestGmpExtensions.q_neg_test;
const
N1 = -5;
D1 = 3;
var negated_operand, operand, n2: MPRational;
begin
q_init(negated_operand);
q_init(operand);
q_set_si(operand, N1, D1);
q_neg(negated_operand, operand);
assert(q_cmp_si(negated_operand, -N1, D1) = 0);
n2 := q_neg(operand);
assert(q_cmp_si(n2, -N1, D1) = 0);
end;
procedure TTestGmpExtensions.q_abs_test;
const
N1 = 5;
D1 = 3;
var rop, op, r2: MPRational;
begin
q_init(rop);
q_init(op);
q_set_si(op, -N1, D1);
q_abs(rop, op);
assert(q_cmp_si(rop, N1, D1) = 0);
r2 := q_abs(op);
assert(q_cmp_si(r2, N1, D1) = 0);
end;
procedure TTestGmpExtensions.q_inv_test;
const
N1 = -5;
D1 = 3;
var inverted_number, number, i2: MPRational;
begin
q_init(inverted_number);
q_init(number);
q_set_si(number, N1, D1);
q_inv(inverted_number, number);
assert(q_cmp_si(inverted_number, -D1, -N1) = 0);
i2 := q_inv(number);
assert(q_cmp_si(i2, -D1, -N1) = 0);
end;
procedure TTestGmpExtensions.q_cmp_test;
const
N1 = -7;
D1 = 5;
var op1, op2: MPRational;
begin
q_init(op1);
q_init(op2);
q_set_si(op1, N1, D1);
q_set_si(op2, N1, D1);
assert(q_cmp(op1, op2) = 0);
q_set_si(op1, N1 + 1, D1);
assert(q_cmp(op1, op2) > 0);
q_set_si(op1, N1 - 1, D1);
assert(q_cmp(op1, op2) < 0);
end;
procedure TTestGmpExtensions.q_cmp_si_test;
const
N1 = -7;
D1 = 5;
var op1: MPRational;
begin
q_init(op1);
q_set_si(op1, N1, D1);
assert(q_cmp_si(op1, N1, D1) = 0);
assert(q_cmp_si(op1, N1 - 1, D1) > 0);
assert(q_cmp_si(op1, N1 + 1, D1) < 0);
end;
procedure TTestGmpExtensions.q_cmp_ui_test;
const
N1 = 7;
D1 = 5;
var op1: MPRational;
begin
q_init(op1);
q_set_si(op1, N1, D1);
assert(q_cmp_ui(op1, N1, D1) = 0);
assert(q_cmp_ui(op1, N1 - 1, D1) > 0);
assert(q_cmp_ui(op1, N1 + 1, D1) < 0);
end;
procedure TTestGmpExtensions.q_equal_test;
const
N1 = -7;
D1 = 5;
var op1, op2: MPRational;
begin
q_init(op1);
q_init(op2);
q_set_si(op1, N1, D1);
q_set_si(op2, N1, D1);
assert(q_equal(op1, op2));
q_set_si(op1, N1 + 1, D1);
assert(not q_equal(op1, op2));
q_set_si(op1, N1 - 1, D1);
assert(not q_equal(op1, op2));
end;
procedure TTestGmpExtensions.q_get_num_test;
const
N1 = -7;
D1 = 5;
var
rational: MPRational;
numerator, n2: MPInteger;
begin
q_init(rational);
z_init(numerator);
q_set_si(rational, N1, D1);
q_get_num(numerator, rational);
assert(z_get_si(numerator) = N1);
n2 := q_get_num(rational);
assert(z_get_si(n2) = N1);
end;
procedure TTestGmpExtensions.q_get_den_test;
const
N1 = -7;
D1 = 5;
var
rational: MPRational;
denominator, d2: MPInteger;
begin
q_init(rational);
z_init(denominator);
q_set_si(rational, N1, D1);
q_get_den(denominator, rational);
assert(z_get_si(denominator) = D1);
d2 := q_get_den(rational);
assert(z_get_si(d2) = D1);
end;
procedure TTestGmpExtensions.q_set_num_test;
const
N1 = -7;
D1 = 5;
N2 = 3;
var
rational: MPRational;
numerator: MPInteger;
begin
q_init(rational);
z_init_set_si(numerator, N2);
q_set_si(rational, N1, D1);
q_set_num(rational, numerator);
assert(q_cmp_si(rational, N2, D1) = 0);
end;
procedure TTestGmpExtensions.q_set_den_test;
const
N1 = -7;
D1 = 5;
D2 = 3;
var
rational: MPRational;
denominator: MPInteger;
begin
q_init(rational);
z_init_set_si(denominator, D2);
q_set_si(rational, N1, D1);
q_set_den(rational, denominator);
assert(q_cmp_si(rational, N1, D2) = 0);
end;
procedure TTestGmpExtensions.f_get_default_prec_test;
begin
assert(f_get_default_prec > 0);
end;
procedure TTestGmpExtensions.f_set_default_prec_test;
var prec: valuint;
begin
prec := f_get_default_prec;
f_set_default_prec(2 * prec);
assert(f_get_default_prec = 2 * prec);
f_set_default_prec(prec);
end;
procedure TTestGmpExtensions.f_init_test;
var x: MPFloat;
begin
f_init(x);
assert(f_get_prec(x) = f_get_default_prec);
end;
procedure TTestGmpExtensions.f_init2_test;
var x: MPFloat;
begin
f_init2(x, 2 * f_get_default_prec);
assert(f_get_prec(x) = 2 * f_get_default_prec);
end;
procedure TTestGmpExtensions.f_clear_test;
var x: MPFloat;
begin
f_init(x);
f_clear(x);
end;
procedure TTestGmpExtensions.f_get_prec_test;
var x: MPFloat;
begin
f_init(x);
f_set_prec(x, 2 * f_get_default_prec);
assert(f_get_prec(x) = 2 * f_get_default_prec);
end;
procedure TTestGmpExtensions.f_set_prec_test;
var x: MPFloat;
begin
f_init(x);
f_set_prec(x, 2 * f_get_default_prec);
assert(f_get_prec(x) = 2 * f_get_default_prec);
end;
procedure TTestGmpExtensions.f_set_prec_raw_test;
const N = 10;
var x: MPFloat;
begin
f_init2(x, N * f_get_default_prec);
f_set_prec_raw(x, f_get_default_prec);
f_set_prec_raw(x, N * f_get_default_prec);
end;
procedure TTestGmpExtensions.f_set_q_test;
const OP_ = -10;
var
op: MPRational;
rop: MPFloat;
begin
q_init(op);
f_init(rop);
q_set_si(op, OP_, 1);
f_set_q(rop, op);
assert(f_get_si(rop) = OP_);
end;
procedure TTestGmpExtensions.f_set_ui_test;
const OP = 1000000;
var rop: MPFloat;
begin
f_init(rop);
f_set_ui(rop, OP);
assert(f_get_ui(rop) = OP);
end;
procedure TTestGmpExtensions.f_get_ui_test;
const OP = 1000000;
var rop: MPFloat;
begin
f_init(rop);
f_set_ui(rop, OP);
assert(f_get_ui(rop) = OP);
end;
procedure TTestGmpExtensions.f_set_si_test;
const OP = -1000000;
var rop: MPFloat;
begin
f_init(rop);
f_set_si(rop, OP);
assert(f_get_si(rop) = OP);
end;
procedure TTestGmpExtensions.f_get_si_test;
const OP = -1000000;
var rop: MPFloat;
begin
f_init(rop);
f_set_si(rop, OP);
assert(f_get_si(rop) = OP);
end;
procedure TTestGmpExtensions.f_set_test;
const N = -1000000;
var rop, op: MPFloat;
begin
f_init(rop);
f_init_set_si(op, N);
f_set(rop, op);
assert(f_get_si(rop) = N);
end;
procedure TTestGmpExtensions.f_set_str_test;
const N = -123;
var rop: MPFloat;
begin
f_init(rop);
assert(f_set_str(rop, inttostr(N), BASE10));
assert(f_get_si(rop) = N);
end;
procedure TTestGmpExtensions.f_swap_test;
const
ROP_1 = -13;
ROP_2 = -23;
var rop1, rop2: MPFloat;
begin
f_init_set_si(rop1, ROP_1);
f_init_set_si(rop2, ROP_2);
f_swap(rop1, rop2);
assert(f_get_si(rop1) = ROP_2);
assert(f_get_si(rop2) = ROP_1);
end;
procedure TTestGmpExtensions.f_get_d_test;
const N = -1.5;
var rop: MPFloat;
begin
f_init_set_d(rop, N);
assert(f_get_d(rop) = N);
end;
procedure TTestGmpExtensions.f_set_d_test;
const N = -1.5;
var rop: MPFloat;
begin
f_init(rop);
f_set_d(rop, N);
assert(f_get_d(rop) = N);
end;
procedure TTestGmpExtensions.f_set_z_test;
const
OP_1 = -13;
var
rop: MPFloat;
op: MPInteger;
begin
f_init(rop);
z_init_set_si(op, OP_1);
f_set_z(rop, op);
assert(f_get_si(rop) = OP_1);
end;
procedure TTestGmpExtensions.f_get_d_2exp_test;
const
M = 0.5;
E = 4;
N = (1 shl E) div 2;
var
rop: MPFloat;
exp: valsint;
begin
f_init_set_d(rop, N);
exp := -1;
assert(f_get_d_2exp(exp, rop) = M);
assert(exp = E);
end;
procedure TTestGmpExtensions.f_get_str_test;
const
N = 3.1416;
S = '31416';
E = 1;
var
op: MPFloat;
p: pchar;
exp: mp_exp_t;
s1: string;
begin
f_init_set_d(op, N);
p := f_get_str(nil, exp, BASE10, length(S), op);
assert(p = S);
assert(exp = E);
freemem(p);
setlength(s1, length(S));
assert(pointer(f_get_str(pchar(s1), exp, BASE10, length(s), op)) = pointer(s1));
assert(s1 = S);
s1 := f_get_str(exp, BASE10, length(S), op);
assert(s1 = S);
end;
procedure TTestGmpExtensions.f_add_test;
const
OP1_ = 1;
OP2_ = 2;
var rop, op1, op2, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
f_add(rop, op1, op2);
assert(f_get_d(rop) = OP1_ + OP2_);
r2 := f_add(op1, op2);
assert(f_get_d(r2) = OP1_ + OP2_);
end;
procedure TTestGmpExtensions.f_add_ui_test;
const
OP1_ = 1;
OP2_ = 2;
var rop, op1, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_add_ui(rop, op1, OP2_);
assert(f_get_d(rop) = OP1_ + OP2_);
r2 := f_add_ui(op1, OP2_);
assert(f_get_d(r2) = OP1_ + OP2_);
end;
procedure TTestGmpExtensions.f_sub_test;
const
OP1_ = 3;
OP2_ = 1;
var rop, op1, op2, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
f_sub(rop, op1, op2);
assert(f_get_d(rop) = OP1_ - OP2_);
r2 := f_sub(op1, op2);
assert(f_get_d(r2) = OP1_ - OP2_);
end;
procedure TTestGmpExtensions.f_sub_ui_test;
const
OP1_ = 3;
OP2_ = 1;
var rop, op1, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_sub_ui(rop, op1, OP2_);
assert(f_get_d(rop) = OP1_ - OP2_);
r2 := f_sub_ui(op1, OP2_);
assert(f_get_d(r2) = OP1_ - OP2_);
end;
procedure TTestGmpExtensions.f_ui_sub_test;
const
OP1_ = 3;
OP2_ = 1;
var rop, op2, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op2, OP2_);
f_ui_sub(rop, OP1_, op2);
assert(f_get_d(rop) = OP1_ - OP2_);
r2 := f_ui_sub(OP1_, op2);
assert(f_get_d(r2) = OP1_ - OP2_);
end;
procedure TTestGmpExtensions.f_mul_test;
const
OP1_ = 2;
OP2_ = 3;
var rop, op1, op2, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
f_mul(rop, op1, op2);
assert(f_get_d(rop) = OP1_ * OP2_);
r2 := f_mul(op1, op2);
assert(f_get_d(r2) = OP1_ * OP2_);
end;
procedure TTestGmpExtensions.f_mul_ui_test;
const
OP1_ = 2;
OP2_ = 3;
var rop, op1, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_mul_ui(rop, op1, OP2_);
assert(f_get_d(rop) = OP1_ * OP2_);
r2 := f_mul_ui(op1, OP2_);
assert(f_get_d(r2) = OP1_ * OP2_);
end;
procedure TTestGmpExtensions.f_mul_2exp_test;
const
OP1_ = 3;
OP2_ = 4;
var rop, op1, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_mul_2exp(rop, op1, OP2_);
assert(f_get_d(rop) = OP1_ * (1 shl OP2_));
r2 := f_mul_2exp(op1, OP2_);
assert(f_get_d(r2) = OP1_ * (1 shl OP2_));
end;
procedure TTestGmpExtensions.f_div_test;
const
OP1_ = 6;
OP2_ = 2;
var rop, op1, op2, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
f_div(rop, op1, op2);
assert(f_get_d(rop) = OP1_ / OP2_);
r2 := f_div(op1, op2);
assert(f_get_d(r2) = OP1_ / OP2_);
end;
procedure TTestGmpExtensions.f_div_ui_test;
const
OP1_ = 6;
OP2_ = 2;
var rop, op1, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_div_ui(rop, op1, OP2_);
assert(f_get_d(rop) = OP1_ / OP2_);
r2 := f_div_ui(op1, OP2_);
assert(f_get_d(r2) = OP1_ / OP2_);
end;
procedure TTestGmpExtensions.f_ui_div_test;
const
OP1_ = 6;
OP2_ = 2;
var rop, op2, r2: MPFloat;
begin
f_init(rop);
f_init_set_si(op2, OP2_);
f_ui_div(rop, OP1_, op2);
assert(f_get_d(rop) = OP1_ / OP2_);
r2 := f_ui_div(OP1_, op2);
assert(f_get_d(r2) = OP1_ / OP2_);
end;
procedure TTestGmpExtensions.f_div_2exp_test;
const
OP1_ = 16;
OP2_ = 2;
var rop, op1, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_div_2exp(rop, op1, OP2_);
assert(f_get_d(rop) = OP1_ / (1 shl OP2_));
r2 := f_div_2exp(op1, OP2_);
assert(f_get_d(r2) = OP1_ / (1 shl OP2_));
end;
procedure TTestGmpExtensions.f_sqrt_test;
const
OP_ = 4;
var rop, op, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op, OP_);
f_sqrt(rop, op);
assert(f_get_d(rop) = sqrt(OP_));
r2 := f_sqrt(op);
assert(f_get_d(r2) = sqrt(OP_));
end;
procedure TTestGmpExtensions.f_sqrt_ui_test;
const
OP_ = 4;
var rop, r2: MPFloat;
begin
f_init(rop);
f_sqrt_ui(rop, OP_);
assert(f_get_d(rop) = sqrt(OP_));
r2 := f_sqrt_ui(OP_);
assert(f_get_d(r2) = sqrt(OP_));
end;
procedure TTestGmpExtensions.f_pow_ui_test;
const
OP1_ = 3;
OP2_ = 2;
var rop, op1, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_pow_ui(rop, op1, OP2_);
assert(f_get_d(rop) = OP1_ ** OP2_);
r2 := f_pow_ui(op1, OP2_);
assert(f_get_d(r2) = OP1_ ** OP2_);
end;
procedure TTestGmpExtensions.f_neg_test;
const
OP_ = 4;
var rop, op, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op, OP_);
f_neg(rop, op);
assert(f_get_d(rop) = -OP_);
r2 := f_neg(op);
assert(f_get_d(r2) = -OP_);
end;
procedure TTestGmpExtensions.f_abs_test;
const OP_ = -4;
var rop, op, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op, OP_);
f_abs(rop, op);
assert(f_get_d(rop) = -OP_);
r2 := f_abs(op);
assert(f_get_d(r2) = -OP_);
end;
procedure TTestGmpExtensions.f_cmp_test;
const OP_1 = -10;
var op1, op2: MPFloat;
begin
f_init_set_si(op1, OP_1);
f_init_set_si(op2, OP_1);
assert(f_cmp(op1, op2) = 0);
f_set_si(op2, OP_1 + 1);
assert(f_cmp(op1, op2) < 0);
f_set_si(op2, OP_1 - 1);
assert(f_cmp(op1, op2) > 0);
end;
procedure TTestGmpExtensions.f_cmp_d_test;
const OP_ = -10;
var op: MPFloat;
begin
f_init_set_si(op, OP_);
assert(f_cmp_d(op, OP_) = 0);
assert(f_cmp_d(op, OP_ + 1) < 0);
assert(f_cmp_d(op, OP_ - 1) > 0);
end;
procedure TTestGmpExtensions.f_cmp_si_test;
const OP_ = -10;
var op: MPFloat;
begin
f_init_set_si(op, OP_);
assert(f_cmp_si(op, OP_) = 0);
assert(f_cmp_si(op, OP_ + 1) < 0);
assert(f_cmp_si(op, OP_ - 1) > 0);
end;
procedure TTestGmpExtensions.f_cmp_ui_test;
const OP_ = 10;
var op: MPFloat;
begin
f_init_set_si(op, OP_);
assert(f_cmp_ui(op, OP_) = 0);
assert(f_cmp_ui(op, OP_ + 1) < 0);
assert(f_cmp_ui(op, OP_ - 1) > 0);
end;
procedure TTestGmpExtensions.f_eq_test;
const
OP_1 = 10;
OP_3 = 8;
var op1, op2: MPFloat;
begin
f_init_set_si(op1, OP_1);
f_init_set_si(op2, OP_1);
assert(f_eq(op1, op2, OP_3));
end;
procedure TTestGmpExtensions.f_reldiff_test;
const
OP1_ = 4;
OP2_ = 2;
var rop, op1, op2, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
f_reldiff(rop, op1, op2);
assert(f_get_d(rop) = abs(OP1_ - OP2_) / OP1_);
r2 := f_reldiff(op1, op2);
assert(f_get_d(r2) = abs(OP1_ - OP2_) / OP1_);
end;
procedure TTestGmpExtensions.f_ceil_test;
const N = 3.1;
var rop, op, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op, N);
f_ceil(rop, op);
assert(f_get_d(rop) = ceil(N));
r2 := f_ceil(op);
assert(f_get_d(r2) = ceil(N));
end;
procedure TTestGmpExtensions.f_floor_test;
const N = 3.9;
var rop, op, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op, N);
f_floor(rop, op);
assert(f_get_d(rop) = floor(N));
r2 := f_floor(op);
assert(f_get_d(r2) = floor(N));
end;
procedure TTestGmpExtensions.f_trunc_test;
const N = -3.9;
var rop, op, r2: MPFloat;
begin
f_init(rop);
f_init_set_d(op, N);
f_trunc(rop, op);
assert(f_get_d(rop) = trunc(N));
r2 := f_trunc(op);
assert(f_get_d(r2) = trunc(N));
end;
procedure TTestGmpExtensions.f_integer_p_test;
const
N1 = 10;
N2 = 10.1;
var op: MPFloat;
begin
f_init_set_si(op, N1);
assert(f_integer_p(op));
f_set_d(op, N2);
assert(not f_integer_p(op));
end;
procedure TTestGmpExtensions.f_fits_ushort_p_test;
var op: MPFloat;
begin
f_init_set_ui(op, high(word));
assert(f_fits_ushort_p(op));
f_add_ui(op, op, 1);
assert(not f_fits_ushort_p(op));
end;
procedure TTestGmpExtensions.f_fits_sshort_p_test;
var op: MPFloat;
begin
f_init_set_ui(op, high(smallint));
assert(f_fits_sshort_p(op));
f_add_ui(op, op, 1);
assert(not f_fits_sshort_p(op));
f_clear(op);
end;
procedure TTestGmpExtensions.f_fits_uint_p_test;
var op: MPFloat;
begin
f_init_set_ui(op, high(cardinal));
assert(f_fits_uint_p(op));
f_add_ui(op, op, 1);
assert(not f_fits_uint_p(op));
f_clear(op);
end;
procedure TTestGmpExtensions.f_fits_sint_p_test;
var op: MPFloat;
begin
f_init_set_ui(op, high(integer));
assert(f_fits_sint_p(op));
f_add_ui(op, op, 1);
assert(not f_fits_sint_p(op));
f_clear(op);
end;
procedure TTestGmpExtensions.f_fits_ulong_p_test;
var op: MPFloat;
begin
f_init_set_ui(op, high(valuint));
assert(f_fits_ulong_p(op));
f_add_ui(op, op, 1);
assert(not f_fits_ulong_p(op));
f_clear(op);
end;
procedure TTestGmpExtensions.f_fits_slong_p_test;
var op: MPFloat;
begin
f_init_set_ui(op, high(valsint));
assert(f_fits_slong_p(op));
f_add_ui(op, op, 1);
assert(not f_fits_slong_p(op));
f_clear(op);
end;
procedure TTestGmpExtensions.f_urandomb_test;
const NBITS = 100;
var
rop, r2: MPFloat;
state: MPRandState;
cmp: longint;
begin
randinit_default(state);
f_init(rop);
f_urandomb(rop, state, NBITS);
cmp := f_cmp_ui(rop, 0);
assert(cmp >= 0);
assert(f_cmp_ui(rop, 1) < 0);
r2 := f_urandomb(state, NBITS);
cmp := f_cmp_ui(r2, 0);
assert(cmp >= 0);
assert(f_cmp_ui(r2, 1) < 0);
end;
procedure TTestGmpExtensions.f_random2_test;
var
rop, r2: MPFloat;
begin
f_init(rop);
f_random2(rop, 1, 1);
r2 := f_random2(1, 1);
assert(assigned(r2))
end;
procedure TTestGmpExtensions.f_init_set_test;
const N = -1000000;
var rop, op: MPFloat;
begin
f_init_set_si(op, N);
f_init_set(rop, op);
assert(f_get_si(rop) = N);
end;
procedure TTestGmpExtensions.f_init_set_d_test;
const N = -1.5;
var rop: MPFloat;
begin
f_init_set_d(rop, N);
assert(f_get_d(rop) = N);
end;
procedure TTestGmpExtensions.f_init_set_si_test;
const N = -5;
var rop: MPFloat;
begin
f_init_set_si(rop, N);
assert(f_get_si(rop) = N);
end;
procedure TTestGmpExtensions.f_init_set_str_test;
const N = -123;
var rop: MPFloat;
begin
f_init_set_str(rop, inttostr(N), BASE10);
assert(f_get_si(rop) = N);
end;
procedure TTestGmpExtensions.f_init_set_ui_test;
const N = 5;
var rop: MPFloat;
begin
f_init_set_ui(rop, N);
assert(f_get_ui(rop) = N);
end;
{ TTestGmpOperators }
// operator * (op1: MPFloat; op2: MPFloat): MPFloat;
procedure TTestGmpOperators.star__MPFloat__MPFloat__MPFloat_;
const
OP1_ = 2;
OP2_ = 3;
var rop, op1, op2: MPFloat;
begin
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
rop := op1 * op2;
assert(f_get_d(rop) = OP1_ * OP2_);
end;
// operator * (op1: MPInteger; op2: MPInteger): MPInteger;
procedure TTestGmpOperators.star__MPInteger__MPInteger__MPInteger_;
const
OP_1 = -10;
OP_2 = 1000;
var rop, op1, op2: MPInteger;
begin
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
rop := op1 * op2;
assert(z_get_si(rop) = OP_1 * OP_2);
end;
// operator * (op1: MPRational; op2: MPRational): MPRational;
procedure TTestGmpOperators.star__MPRational__MPRational__MPRational_;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var product, multiplier, multiplicant: MPRational;
begin
q_init(multiplier);
q_init(multiplicant);
q_set_si(multiplier, N1, D1);
q_set_si(multiplicant, N2, D2);
product := multiplier * multiplicant;
assert(q_cmp_si(product, N1 * N2, D1 * D2) = 0);
end;
// operator ** (op1: MPFloat; op2: valuint): MPFloat;
procedure TTestGmpOperators.pow__MPFloat_valuint_MPFloat_;
const
OP1_ = 3;
OP2_ = 2;
var rop, op1: MPFloat;
begin
f_init_set_d(op1, OP1_);
rop := op1 ** OP2_;
assert(f_get_d(rop) = OP1_ ** OP2_);
end;
// operator ** (op1: MPInteger; op2: valuint): MPInteger;
procedure TTestGmpOperators.pow__MPInteger_valuint_MPInteger_;
const
BASE_ = 10;
EXP = 3;
var rop, base: MPInteger;
begin
z_init_set_si(base, BASE_);
rop := base ** EXP;
assert(z_get_si(rop) = BASE_ ** EXP);
end;
// operator + (op1: MPFloat; op2: MPFloat): MPFloat;
procedure TTestGmpOperators.plus__MPFloat__MPFloat__MPFloat_;
const
OP1_ = 1;
OP2_ = 2;
var rop, op1, op2: MPFloat;
begin
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
rop := op1 + op2;
assert(f_get_d(rop) = OP1_ + OP2_);
end;
// operator + (op1: MPInteger; op2: MPInteger): MPInteger;
procedure TTestGmpOperators.plus__MPInteger__MPInteger__MPInteger_;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1, op2: MPInteger;
begin
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
rop := op1 + op2;
assert(z_get_si(rop) = OP_1 + OP_2);
end;
// operator + (op1: MPRational; op2: MPRational): MPRational;
procedure TTestGmpOperators.plus__MPRational__MPRational__MPRational_;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var sum, addend1, addend2: MPRational;
begin
q_init(addend1);
q_init(addend2);
q_set_si(addend1, N1, D1);
q_set_si(addend2, N2, D2);
sum := addend1 + addend2;
assert(q_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
end;
// operator - (op: MPFloat): MPFloat;
procedure TTestGmpOperators.minus__MPFloat__MPFloat_;
const
OP_ = 4;
var rop, op: MPFloat;
begin
f_init_set_d(op, OP_);
rop := -op;
assert(f_get_d(rop) = -OP_);
end;
// operator - (op: MPInteger): MPInteger;
procedure TTestGmpOperators.minus__MPInteger__MPInteger_;
const OP_ = 1000;
var rop, op: MPInteger;
begin
z_init_set_si(op, OP_);
rop := -op;
assert(z_get_si(rop) = -OP_);
end;
// operator - (op: MPRational): MPRational;
procedure TTestGmpOperators.minus__MPRational__MPRational_;
const
N1 = -5;
D1 = 3;
var negated_operand, operand: MPRational;
begin
q_init(negated_operand);
q_init(operand);
q_set_si(operand, N1, D1);
negated_operand := - operand;
assert(q_cmp_si(negated_operand, -N1, D1) = 0);
end;
// operator - (op1: MPFloat; op2: MPFloat): MPFloat;
procedure TTestGmpOperators.minus__MPFloat__MPFloat__MPFloat_;
const
OP1_ = 3;
OP2_ = 1;
var rop, op1, op2: MPFloat;
begin
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
rop := op1 - op2;
assert(f_get_d(rop) = OP1_ - OP2_);
end;
// operator - (op1: MPInteger; op2: MPInteger): MPInteger;
procedure TTestGmpOperators.minus__MPInteger__MPInteger__MPInteger_;
const
OP_1 = -1000;
OP_2 = 1000000;
var rop, op1, op2: MPInteger;
begin
z_init_set_si(op1, OP_1);
z_init_set_si(op2, OP_2);
rop := op1 - op2;
assert(z_get_si(rop) = OP_1 - OP_2);
end;
// operator - (op1: MPRational; op2: MPRational): MPRational;
procedure TTestGmpOperators.minus__MPRational__MPRational__MPRational_;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var difference, minuend, subtrahend: MPRational;
begin
q_init(minuend);
q_init(subtrahend);
q_set_si(minuend, N1, D1);
q_set_si(subtrahend, N2, D2);
difference := minuend - subtrahend;
assert(q_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
end;
// operator / (op1: MPFloat; op2: MPFloat): MPFloat;
procedure TTestGmpOperators.slash__MPFloat__MPFloat__MPFloat_;
const
OP1_ = 6;
OP2_ = 2;
var rop, op1, op2: MPFloat;
begin
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
rop := op1 / op2;
assert(f_get_d(rop) = OP1_ / OP2_);
end;
// operator / (op1: MPInteger; op2: MPInteger): MPInteger;
procedure TTestGmpOperators.slash__MPInteger__MPInteger__MPInteger_;
const
N_ = -17;
D_ = 4;
var q, n, d: MPInteger;
begin
z_init_set_si(n, N_);
z_init_set_si(d, D_);
q := n / d;
assert(z_get_si(q) = trunc(N_ / D_));
end;
// operator / (op1: MPRational; op2: MPRational): MPRational;
procedure TTestGmpOperators.slash__MPRational__MPRational__MPRational_;
const
N1 = 5;
D1 = 2;
N2 = -7;
D2 = 3;
var quotient, dividend, divisor: MPRational;
begin
q_init(dividend);
q_init(divisor);
q_set_si(dividend, N1, D1);
q_set_si(divisor, N2, D2);
quotient := dividend / divisor;
assert(q_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
end;
// operator := (op: double): MPFloat;
procedure TTestGmpOperators.assign_double_MPFloat_;
const N = -1.5;
var rop: MPFloat;
begin
rop := N;
assert(f_get_d(rop) = N);
end;
// operator := (op: double): MPInteger;
procedure TTestGmpOperators.assign_double_MPInteger_;
const OP_ = 1000000;
var rop: MPInteger;
begin
rop := OP_;
assert(z_get_si(rop) = OP_);
end;
// operator := (op: double): MPRational;
procedure TTestGmpOperators.assign_double_MPRational_;
const
OP_1 = -1;
OP_2 = 2;
var rop: MPRational;
begin
rop := OP_1 / OP_2;
assert(q_cmp_si(rop, OP_1, OP_2) = 0);
end;
// operator := (op: MPFloat): cardinal;
procedure TTestGmpOperators.assign__MPFloat_Cardinal;
const OP = 1000000;
var rop: MPFloat;
begin
rop := OP;
assert(f_get_ui(rop) = OP);
end;
// operator := (op: MPFloat): double;
procedure TTestGmpOperators.assign__MPFloat_double;
const N = -1.5;
var rop: MPFloat;
begin
rop := N;
assert(f_get_d(rop) = N);
end;
// operator := (op: MPFloat): integer;
procedure TTestGmpOperators.assign__MPFloat_integer;
const OP = -1000000;
var rop: MPFloat;
begin
rop := OP;
assert(f_get_si(rop) = OP);
end;
// operator := (op: MPFloat): mpf_t;
procedure TTestGmpOperators.assign__MPFloat_mpf_t;
const N = -1000000;
var
rop: mpf_t;
op: MPFloat;
begin
f_init_set_si(op, N);
rop := op;
assert(mpf_get_si(rop) = N);
mpf_clear(rop);
end;
// operator := (op: MPFloat): MPInteger;
procedure TTestGmpOperators.assign__MPFloat__MPInteger_;
const OP_ = -10;
var
op: MPFloat;
rop: MPInteger;
begin
f_init_set_si(op, OP_);
rop := op;
assert(z_get_si(rop) = OP_);
end;
// operator := (op: MPFloat): MPRational;
procedure TTestGmpOperators.assign__MPFloat__MPRational_;
const OP_ = -10;
var
op: MPFloat;
rop: MPRational;
begin
f_init_set_si(op, OP_);
rop := op;
assert(q_get_d(rop) = OP_);
end;
// operator := (op: MPFloat): string;
procedure TTestGmpOperators.assign__MPFloat_string;
const
N = 123456;
S = '123456';
var
op: MPFloat;
r: string;
begin
f_init_set_d(op, N);
r := op;
assert(r = S);
end;
// operator := (op: MPFloat): valsint;
procedure TTestGmpOperators.assign__MPFloat_valsint;
const OP_ = -1000000;
var
op: MPFloat;
r: valsint;
begin
f_init_set_si(op, OP_);
r := op;
assert(r = OP_);
end;
// operator := (op: MPFloat): valuint;
procedure TTestGmpOperators.assign__MPFloat_valuint;
const OP_ = 1000000;
var
op: MPFloat;
r: valuint;
begin
f_init_set_si(op, OP_);
r := op;
assert(r = OP_);
end;
// operator := (var op: mpf_t): MPFloat;
procedure TTestGmpOperators.assign_mpf_t_MPFloat_;
const N = -1000000;
var
op: mpf_t;
rop: MPFloat;
begin
mpf_init_set_si(op, N);
rop := op;
assert(f_get_si(rop) = N);
mpf_clear(op);
end;
// operator := (op: MPInteger): cardinal;
procedure TTestGmpOperators.assign__MPInteger_cardinal;
const N = 1000000;
var
op: MPInteger;
r: cardinal;
begin
z_init_set_ui(op, N);
r := op;
assert(r = N);
end;
// operator := (op: MPInteger): double;
procedure TTestGmpOperators.assign__MPInteger_double;
const N = -1000;
var
op: MPInteger;
r: double;
begin
z_init_set_si(op, N);
r := op;
assert(r = N);
end;
// operator := (op: MPInteger): integer;
procedure TTestGmpOperators.assign__MPInteger_integer;
const N = -1000000;
var
op: MPInteger;
r: integer;
begin
z_init_set_si(op, N);
r := op;
assert(r = N);
end;
// operator := (op: MPInteger): MPFloat;
procedure TTestGmpOperators.assign__MPInteger__MPFloat_;
const
OP_1 = -13;
var
rop: MPFloat;
op: MPInteger;
begin
z_init_set_si(op, OP_1);
rop := op;
assert(f_get_si(rop) = OP_1);
end;
// operator := (op: MPInteger): MPRational;
procedure TTestGmpOperators.assign__MPInteger__MPRational_;
const
OP_1 = -13;
var
rational: MPRational;
op: MPInteger;
begin
z_init_set_si(op, OP_1);
rational := op;
assert(q_cmp_si(rational, OP_1, 1) = 0);
end;
// operator := (op: MPInteger): mpz_t;
procedure TTestGmpOperators.assign__MPInteger_mpz_t;
const N = -1000000;
var
rop: mpz_t;
op: MPInteger;
begin
z_init_set_si(op, N);
rop := op;
assert(mpz_get_si(rop) = N);
mpz_clear(rop);
end;
// operator := (op: MPInteger): string;
procedure TTestGmpOperators.assign__MPInteger_string;
const
N = 123456;
S = '123456';
var
op: MPInteger;
r: string;
begin
z_init_set_ui(op, N);
r := op;
assert(r = S);
end;
// operator := (op: MPInteger): valsint;
procedure TTestGmpOperators.assign__MPInteger_valsint;
const N = -1000000;
var
op: MPInteger;
r: valsint;
begin
z_init_set_si(op, N);
r := op;
assert(r = N);
end;
// operator := (op: MPInteger): valuint;
procedure TTestGmpOperators.assign__MPInteger_valuint;
const N = 1000000;
var
op: MPInteger;
r: valuint;
begin
z_init_set_ui(op, N);
r := op;
assert(r = N);
end;
// operator := (var op: mpq_t): MPRational;
procedure TTestGmpOperators.assign_mpq_t_MPRational_;
const
N = -17;
D = 3;
var
op: mpq_t;
rop: MPRational;
begin
mpq_init(op);
mpq_set_si(op, N, D);
rop := op;
assert(q_cmp_si(rop, N, D) = 0);
mpq_clear(op);
end;
// operator := (op: MPRandState): randstate_t;
procedure TTestGmpOperators.assign__MPRandState_randstate_t;
var
op: MPRandState;
rop: randstate_t;
begin
randinit_default(op);
rop := op;
assert(rnd_test(rop));
mp_randclear(rop);
end;
// operator := (op: MPRational): double;
procedure TTestGmpOperators.assign__MPRational_double;
const
OP_1 = -1;
OP_2 = 2;
var
op: MPRational;
r: double;
begin
q_init(op);
q_set_si(op, OP_1, OP_2);
r := op;
assert(r = OP_1 / OP_2);
end;
// operator := (op: MPRational): MPFloat;
procedure TTestGmpOperators.assign__MPRational__MPFloat_;
const OP_ = -10;
var
op: MPRational;
rop: MPFloat;
begin
q_init(op);
q_set_si(op, OP_, 1);
rop := op;
assert(f_get_si(rop) = OP_);
end;
// operator := (op: MPRational): MPInteger;
procedure TTestGmpOperators.assign__MPRational__MPInteger_;
const OP_ = -10;
var
op: MPRational;
rop: MPInteger;
begin
q_init(op);
q_set_si(op, OP_, 1);
rop := op;
assert(z_get_si(rop) = OP_);
end;
// operator := (op: MPRational): mpq_t;
procedure TTestGmpOperators.assign__MPRational_mpq_t;
const
OP_1 = -13;
OP_2 = 17;
var
rational: mpq_t;
op: MPRational;
begin
q_init(op);
q_set_si(op, OP_1, OP_2);
rational := op;
assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
mpq_clear(rational);
end;
// operator := (op: MPRational): string;
procedure TTestGmpOperators.assign__MPRational_string;
const
N = 5;
D = 3;
S = '5/3';
var
op: MPRational;
r: string;
begin
q_init(op);
q_set_si(op, N, D);
r := op;
assert(r = S);
end;
// operator := (var op: mpz_t): MPInteger;
procedure TTestGmpOperators.assign_mpz_t_MPInteger_;
const N = -1000000;
var
op: mpz_t;
rop: MPInteger;
begin
mpz_init_set_si(op, N);
rop := op;
assert(z_get_si(rop) = N);
mpz_clear(op);
end;
// operator := (var op: randstate_t): MPRandState;
procedure TTestGmpOperators.assign_randstate_t_MPRandState_;
var
op: randstate_t;
rop: MPRandState;
begin
mp_randinit_default(op);
rop := op;
assert(rnd_test(rop.ptr^));
mp_randclear(op);
end;
// operator := (op: string): MPFloat;
procedure TTestGmpOperators.assign_string_MPFloat_;
const N = -123;
var rop: MPFloat;
begin
rop := inttostr(N);
assert(f_get_si(rop) = N);
end;
// operator := (op: string): MPInteger;
procedure TTestGmpOperators.assign_string_MPInteger_;
const N = -123;
var rop: MPInteger;
begin
rop := inttostr(N);
assert(z_get_si(rop) = N);
end;
// operator := (op: string): MPRational;
procedure TTestGmpOperators.assign_string_MPRational_;
const
N = 5;
D = 3;
S = '5/3';
var rop: MPRational;
begin
rop := S;
assert(q_cmp_si(rop, N, D) = 0);
end;
// operator := (op: valsint): MPFloat;
procedure TTestGmpOperators.assign_valsint_MPFloat_;
const OP = -1000000;
var rop: MPFloat;
begin
rop := OP;
assert(f_get_si(rop) = OP);
end;
// operator := (op: valsint): MPInteger;
procedure TTestGmpOperators.assign_valsint_MPInteger_;
const OP = -1000000;
var rop: MPInteger;
begin
rop := OP;
assert(z_get_si(rop) = OP);
end;
// operator := (op: valsint): MPRational;
procedure TTestGmpOperators.assign_valsint_MPRational_;
const OP = -1000000;
var rop: MPRational;
begin
rop := OP;
assert(q_cmp_si(rop, OP, 1) = 0);
end;
// operator := (op: valuint): MPFloat;
procedure TTestGmpOperators.assign_valuint_MPFloat_;
const OP = 1000000;
var rop: MPFloat;
begin
rop := OP;
assert(f_get_ui(rop) = OP);
end;
// operator := (op: valuint): MPInteger;
procedure TTestGmpOperators.assign_valuint_MPInteger_;
const OP = 1000000;
var rop: MPInteger;
begin
rop := OP;
assert(z_get_ui(rop) = OP);
end;
// operator := (op: valuint): MPRational;
procedure TTestGmpOperators.assign_valuint_MPRational_;
const OP = 1000000;
var rop: MPRational;
begin
rop := OP;
assert(q_cmp_ui(rop, OP, 1) = 0);
end;
// operator < (op1: MPFloat; op2: MPFloat): boolean;
procedure TTestGmpOperators.lt__MPFloat__MPFloat_boolean;
const
OP1_ = 1.2;
OP2_ = OP1_ + 1;
var op1, op2: MPFloat;
begin
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
assert(op1 < op2);
end;
// operator < (op1: MPInteger; op2: MPInteger): boolean;
procedure TTestGmpOperators.lt__MPInteger__MPInteger_boolean;
const
OP1_ = 12;
OP2_ = OP1_ + 1;
var op1, op2: MPInteger;
begin
z_init_set_d(op1, OP1_);
z_init_set_d(op2, OP2_);
assert(op1 < op2);
end;
// operator < (op1: MPRational; op2: MPRational): boolean;
procedure TTestGmpOperators.lt__MPRational__MPRational_boolean;
const
OP1_ = 12;
OP2_ = OP1_ + 1;
var op1, op2: MPRational;
begin
q_init(op1);
q_init(op2);
q_set_si(op1, OP1_, 1);
q_set_si(op2, OP2_, 1);
assert(op1 < op2);
end;
// operator <= (op1: MPFloat; op2: MPFloat): boolean;
procedure TTestGmpOperators.le__MPFloat__MPFloat_boolean;
const
OP1_ = 1.2;
OP2_ = OP1_ + 1;
var op1, op2: MPFloat;
begin
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
assert(op1 <= op2);
f_set_d(op2, OP1_);
assert(op1 <= op2);
end;
// operator <= (op1: MPInteger; op2: MPInteger): boolean;
procedure TTestGmpOperators.le__MPInteger__MPInteger_boolean;
const
OP1_ = 12;
OP2_ = OP1_ + 1;
var op1, op2: MPInteger;
begin
z_init_set_ui(op1, OP1_);
z_init_set_ui(op2, OP2_);
assert(op1 <= op2);
z_set_ui(op2, OP1_);
assert(op1 <= op2);
end;
// operator <= (op1: MPRational; op2: MPRational): boolean;
procedure TTestGmpOperators.le__MPRational__MPRational_boolean;
const
OP1_ = 12;
OP2_ = OP1_ + 1;
var op1, op2: MPRational;
begin
q_init(op1);
q_init(op2);
q_set_si(op1, OP1_, 1);
q_set_si(op2, OP2_, 1);
assert(op1 <= op2);
q_set_si(op2, OP1_, 1);
assert(op1 <= op2);
end;
// operator > (op1: MPFloat; op2: MPFloat): boolean;
procedure TTestGmpOperators.gt__MPFloat__MPFloat_boolean;
const
OP1_ = 1.2;
OP2_ = OP1_ - 1;
var op1, op2: MPFloat;
begin
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
assert(op1 > op2);
end;
// operator > (op1: MPInteger; op2: MPInteger): boolean;
procedure TTestGmpOperators.gt__MPInteger__MPInteger_boolean;
const
OP1_ = 12;
OP2_ = OP1_ - 1;
var op1, op2: MPInteger;
begin
z_init_set_d(op1, OP1_);
z_init_set_d(op2, OP2_);
assert(op1 > op2);
end;
// operator > (op1: MPRational; op2: MPRational): boolean;
procedure TTestGmpOperators.gt__MPRational__MPRational_boolean;
const
OP1_ = 12;
OP2_ = OP1_ - 1;
var op1, op2: MPRational;
begin
q_init(op1);
q_init(op2);
q_set_si(op1, OP1_, 1);
q_set_si(op2, OP2_, 1);
assert(op1 > op2);
end;
// operator >= (op1: MPFloat; op2: MPFloat): boolean;
procedure TTestGmpOperators.ge__MPFloat__MPFloat_boolean;
const
OP1_ = 1.2;
OP2_ = OP1_ - 1;
var op1, op2: MPFloat;
begin
f_init_set_d(op1, OP1_);
f_init_set_d(op2, OP2_);
assert(op1 >= op2);
f_set_d(op2, OP1_);
assert(op1 >= op2);
end;
// operator >= (op1: MPInteger; op2: MPInteger): boolean;
procedure TTestGmpOperators.ge__MPInteger__MPInteger_boolean;
const
OP1_ = 12;
OP2_ = OP1_ - 1;
var op1, op2: MPInteger;
begin
z_init_set_ui(op1, OP1_);
z_init_set_ui(op2, OP2_);
assert(op1 >= op2);
z_set_ui(op2, OP1_);
assert(op1 >= op2);
end;
// operator >= (op1: MPRational; op2: MPRational): boolean;
procedure TTestGmpOperators.ge__MPRational__MPRational_boolean;
const
OP1_ = 12;
OP2_ = OP1_ - 1;
var op1, op2: MPRational;
begin
q_init(op1);
q_init(op2);
q_set_si(op1, OP1_, 1);
q_set_si(op2, OP2_, 1);
assert(op1 >= op2);
q_set_si(op2, OP1_, 1);
assert(op1 >= op2);
end;
