220 lines
6.1 KiB
C++
220 lines
6.1 KiB
C++
/*=============================================================================
|
|
|
|
This file is part of FLINT.
|
|
|
|
FLINT is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
FLINT is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with FLINT; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
=============================================================================*/
|
|
/******************************************************************************
|
|
|
|
Copyright (C) 2013 Tom Bachmann
|
|
|
|
******************************************************************************/
|
|
|
|
#include <iostream>
|
|
|
|
#include "padic_polyxx.h"
|
|
#include "flintxx/test/helpers.h"
|
|
|
|
using namespace flint;
|
|
|
|
padicxx_ctx ctx(fmpzxx(5), 10, 20, PADIC_TERSE);
|
|
|
|
void
|
|
test_init()
|
|
{
|
|
padic_polyxx a(ctx, 20);
|
|
tassert(a.get_ctx()._ctx() == ctx._ctx());
|
|
tassert(a.prec() == 20);
|
|
|
|
padic_polyxx c(a);
|
|
tassert(a == c);
|
|
|
|
padic_polyxx b(ctx, 30);
|
|
tassert((a + b).estimate_ctx()._ctx() == ctx._ctx());
|
|
tassert((a + b).prec() == 30);
|
|
|
|
tassert((a + b).create_temporary().prec() == 30);
|
|
padic_polyxx d((a + b).create_temporary());
|
|
tassert(d.get_ctx()._ctx() == ctx._ctx());
|
|
tassert(d.prec() == 30);
|
|
|
|
padic_polyxx e(a + b);
|
|
tassert(e.prec() == 30);
|
|
|
|
tassert(padic_polyxx::zero(ctx).is_zero()
|
|
&& padic_polyxx::zero(ctx, 25).is_zero());
|
|
tassert(padic_polyxx::one(ctx).is_one()
|
|
&& padic_polyxx::one(ctx, 25).is_one());
|
|
|
|
a.prec() = 25;
|
|
tassert(a.prec() == 25);
|
|
a.val() = 17;
|
|
tassert(a.val() == 17);
|
|
}
|
|
|
|
void
|
|
test_assignment()
|
|
{
|
|
padic_polyxx a(ctx, 20), b(ctx, 20);
|
|
ulong o1 = 1;
|
|
slong o2 = 1;
|
|
fmpzxx o3(1);
|
|
fmpqxx o4 = fmpqxx::integer(o3);
|
|
fmpz_polyxx o5 = fmpz_polyxx::from_ground(o3);
|
|
fmpq_polyxx o6;o6.set_coeff(0, o4);
|
|
|
|
a = o1;tassert(a.is_one());a = 0;
|
|
a = o2;tassert(a.is_one());a = 0;
|
|
a = o3;tassert(a.is_one());a = 0;
|
|
a = o4;tassert(a.is_one());a = 0;
|
|
a = o5;tassert(a.is_one());a = 0;
|
|
a = o6;tassert(a.is_one());
|
|
|
|
tassert(a != b);
|
|
a = b;
|
|
tassert(a == b);
|
|
|
|
a = padicxx::from_QQ(1, ctx);tassert(a.is_one());
|
|
}
|
|
|
|
void
|
|
test_conversion()
|
|
{
|
|
tassert(padic_polyxx::from_QQ(1, ctx).is_one());
|
|
tassert(padic_polyxx::from_QQX(fmpz_polyxx::from_ground(1), ctx).is_one());
|
|
tassert(padic_polyxx::from_ground(padicxx::one(ctx)).is_one());
|
|
|
|
frandxx state;
|
|
fmpz_polyxx f = fmpz_polyxx::randtest_unsigned(state, 5, 10);
|
|
tassert(padic_polyxx::from_QQX(f, ctx, 100).to<fmpz_polyxx>() == f);
|
|
fmpq_polyxx fq;fq = f;
|
|
tassert(padic_polyxx::from_QQX(f, ctx, 100).to<fmpq_polyxx>() == fq);
|
|
}
|
|
|
|
void
|
|
test_arithmetic()
|
|
{
|
|
frandxx state;
|
|
padicxx a = padicxx::randtest(state, ctx);
|
|
padicxx b = padicxx::randtest(state, ctx);
|
|
padic_polyxx ap = padic_polyxx::from_ground(a);
|
|
padic_polyxx bp = padic_polyxx::from_ground(b);
|
|
|
|
tassert(ap + bp == padic_polyxx::from_ground(a + b));
|
|
tassert(ap - bp == padic_polyxx::from_ground(a - b));
|
|
tassert(ap * bp == padic_polyxx::from_ground(a * b));
|
|
tassert(-ap == padic_polyxx::from_ground(-a));
|
|
tassert(ap * b == padic_polyxx::from_ground(a * b));
|
|
}
|
|
|
|
void
|
|
test_functions()
|
|
{
|
|
frandxx state;
|
|
|
|
padic_polyxx p = padic_polyxx::randtest(state, 4, ctx, 25);
|
|
tassert(p.pow(3u) == p*p*p);
|
|
tassert(p.degree() == 3);
|
|
tassert(p.length() == 4);
|
|
tassert(p.val() + 1 == (p*padicxx::from_QQ(5, ctx, 25)).val());
|
|
|
|
fmpz_polyxx F1 = fmpz_polyxx::randtest(state, 5, 10);
|
|
fmpz_polyxx F2 = fmpz_polyxx::randtest(state, 5, 10);
|
|
padic_polyxx f1 = padic_polyxx::from_QQX(F1, ctx);
|
|
padic_polyxx f2 = padic_polyxx::from_QQX(F2, ctx);
|
|
tassert(f1.derivative() == padic_polyxx::from_QQX(F1.derivative(), ctx));
|
|
tassert(compose(f1, f2) == padic_polyxx::from_QQX(F1(F2), ctx));
|
|
tassert(f1(f2) == compose(f1, f2));
|
|
|
|
fmpzxx X = fmpzxx::randtest(state, 10);
|
|
padicxx x = padicxx::from_QQ(X, ctx);
|
|
tassert(f1(x) == padicxx::from_QQ(F1(X), ctx));
|
|
|
|
tassert(f1.shift_left(5) == padic_polyxx::from_QQX(F1.shift_left(5), ctx));
|
|
tassert(f1.shift_right(2)
|
|
== padic_polyxx::from_QQX(F1.shift_right(2), ctx));
|
|
|
|
F1.set_coeff(0, 1);
|
|
f1 = padic_polyxx::from_QQX(F1, ctx);
|
|
tassert(f1.inv_series(10) == padic_polyxx::from_QQX(F1.inv_series(10), ctx));
|
|
|
|
f2.set_zero();
|
|
f2.set_coeff(1, padicxx::one(ctx));
|
|
tassert(p.compose_pow(5) == p(f2.pow(5u)));
|
|
|
|
tassert(!padic_polyxx::randtest_not_zero(state, 5, ctx).is_zero());
|
|
tassert(padic_polyxx::randtest_val(state, 5, 5, ctx).val() == 5);
|
|
}
|
|
|
|
// test stuff which we should get automatically - references etc
|
|
void
|
|
test_extras()
|
|
{
|
|
padic_polyxx a = padic_polyxx::from_QQ(fmpqxx(3, 5u), ctx);
|
|
padic_polyxx b = padic_polyxx::from_QQ(fmpqxx(3, 1u), ctx);
|
|
|
|
padic_polyxx_ref ar(a);
|
|
padic_polyxx_srcref asr(a);
|
|
tassert(a == ar && ar == asr);
|
|
ar = 3;
|
|
tassert(a == b && asr == b);
|
|
|
|
tassert(ar + asr == a + a);
|
|
tassert(padic_polyxx(ar) == ar);
|
|
tassert(padic_polyxx(asr) == ar);
|
|
}
|
|
|
|
void
|
|
test_prec()
|
|
{
|
|
padic_polyxx a(ctx, 5), b(ctx, 7);
|
|
padic_polyxx_ref ar(a);
|
|
padic_polyxx_srcref br(b);
|
|
|
|
tassert((a + a).prec() == 5);
|
|
tassert((a + ar).prec() == 5);
|
|
tassert((a + b).prec() == 7);
|
|
tassert((a + br).prec() == 7);
|
|
tassert((a.toN(15) + br.toN(10)).prec() == 15);
|
|
}
|
|
|
|
void
|
|
test_printing()
|
|
{
|
|
padic_polyxx p(ctx);
|
|
p.set_coeff(2, padicxx::one(ctx));
|
|
tassert_fprint(p, "3 0 0 1");
|
|
tassert_fprint_pretty(p, "x", "x^2");
|
|
}
|
|
|
|
int
|
|
main()
|
|
{
|
|
std::cout << "padic_polyxx....";
|
|
|
|
test_init();
|
|
test_assignment();
|
|
test_conversion();
|
|
test_arithmetic();
|
|
test_functions();
|
|
test_extras();
|
|
test_prec();
|
|
test_printing();
|
|
|
|
std::cout << "PASS" << std::endl;
|
|
return 0;
|
|
}
|