pqc/external/flint-2.4.3/fmpz_factorxx.h
2014-05-24 23:16:06 +02:00

190 lines
5.6 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
******************************************************************************/
#ifndef FMPZ_FACTORXX_H
#define FMPZ_FACTORXX_H
#include "fmpz_factor.h"
#include "fmpz_vec.h"
#include "flintxx/ltuple.h"
// TODO codegen
// TODO factor_pp1 multiple return values
namespace flint {
FLINT_DEFINE_THREEARY(factor_trial_range)
FLINT_DEFINE_UNOP(expand)
FLINT_DEFINE_UNOP(expand_iterative)
FLINT_DEFINE_UNOP(expand_multiexp)
namespace detail {
template<class Delay>
class fmpz_factorxx_delayed
{
private:
fmpz_factor_t inner;
void copy_init(const fmpz_factorxx_delayed& o)
{
_fmpz_factor_fit_length(inner, o.inner->num);
_fmpz_factor_set_length(inner, o.inner->num);
inner->sign = o.inner->sign;
for(slong i = 0;i < o.inner->num;++i)
{
fmpz_set(inner->p + i, o.inner->p + i);
inner->exp[i] = o.inner->exp[i];
}
}
public:
fmpz_factorxx_delayed() {fmpz_factor_init(inner);}
~fmpz_factorxx_delayed() {fmpz_factor_clear(inner);}
fmpz_factorxx_delayed(const fmpz_factorxx_delayed& o)
{
fmpz_factor_init(inner);
copy_init(o);
}
fmpz_factorxx_delayed& operator=(const fmpz_factorxx_delayed& o)
{
copy_init(o);
return *this;
}
bool operator==(const fmpz_factorxx_delayed& o)
{
if(o.sign() != sign() || o.size() != size())
return false;
for(ulong i = 0;i < size();++i)
if(p(i) != o.p(i) || exp(i) != o.exp(i))
return false;
return true;
}
ulong size() const {return inner->num;}
ulong exp(slong i) const {return inner->exp[i];}
ulong& exp(slong i) {return inner->exp[i];}
fmpzxx_srcref p(slong i) const {return fmpzxx_srcref::make(inner->p + i);}
fmpzxx_ref p(slong i) {return fmpzxx_ref::make(inner->p + i);}
int sign() const {return inner->sign;}
int& sign() {return inner->sign;}
fmpz_factor_t& _data() {return inner;}
const fmpz_factor_t& _data() const {return inner;}
void print() const {fmpz_factor_print(inner);}
template<class Fmpz>
typename mp::enable_if<traits::is_fmpzxx<Fmpz> >::type
set_factor(const Fmpz& f)
{
fmpz_factor(_data(), f.evaluate()._fmpz());
}
template<class T>
typename mp::enable_if<traits::fits_into_slong<T> >::type
set_factor(T t)
{
fmpz_factor_si(_data(), t);
}
template<class Fmpz>
typename mp::enable_if<traits::is_fmpzxx<Fmpz>, bool>::type
set_factor_trial_range(const Fmpz& f, ulong start, ulong nprimes)
{
return fmpz_factor_trial_range(_data(), f.evaluate()._fmpz(),
start, nprimes);
}
template<class Fmpz>
typename mp::enable_if<traits::is_fmpzxx<Fmpz>, bool>::type
set_factor_pp1(const Fmpz& f, ulong B1, ulong B2_sqrt, ulong c)
{
return fmpz_factor_pp1(_data(), f.evaluate()._fmpz(),
B1, B2_sqrt, c);
}
#define FLINTXX_DEFINE_MEMBER_UNOP_EXTRA(funcname, Class, rtype) \
FLINT_UNOP_BUILD_RETTYPE(funcname, rtype, Class) \
funcname() const {return flint::funcname(*this);}
FLINTXX_DEFINE_MEMBER_UNOP_EXTRA(expand, fmpz_factorxx_delayed, fmpzxx)
FLINTXX_DEFINE_MEMBER_UNOP_EXTRA(expand_iterative, fmpz_factorxx_delayed, fmpzxx)
FLINTXX_DEFINE_MEMBER_UNOP_EXTRA(expand_multiexp, fmpz_factorxx_delayed, fmpzxx)
};
} // detail
typedef detail::fmpz_factorxx_delayed<void> fmpz_factorxx;
template<class Fmpz>
inline typename mp::enable_if<mp::or_<
traits::is_fmpzxx<Fmpz>, traits::fits_into_slong<Fmpz> >,
fmpz_factorxx>::type factor(const Fmpz& f)
{
fmpz_factorxx res;
res.set_factor(f);
return res;
}
namespace rules {
namespace rdetail {
typedef make_ltuple<mp::make_tuple<bool, fmpz_factorxx>::type>::type
fmpz_factor_rt;
template<class T> struct signed_or_fmpz
: mp::or_<FMPZXX_COND_S<T>, traits::fits_into_slong<T> > { };
} // rdetail
FLINT_DEFINE_THREEARY_EXPR_COND3(factor_trial_range_op, rdetail::fmpz_factor_rt,
rdetail::signed_or_fmpz,
traits::is_unsigned_integer, traits::is_unsigned_integer,
to.template get<0>() = to.template get<1>().set_factor_trial_range(
e1, e2, e3))
FLINT_DEFINE_UNARY_EXPR_(expand_op, fmpzxx, fmpz_factorxx,
fmpz_factor_expand(to._fmpz(), from._data()))
FLINT_DEFINE_UNARY_EXPR_(expand_iterative_op, fmpzxx, fmpz_factorxx,
fmpz_factor_expand_iterative(to._fmpz(), from._data()))
FLINT_DEFINE_UNARY_EXPR_(expand_multiexp_op, fmpzxx, fmpz_factorxx,
fmpz_factor_expand_multiexp(to._fmpz(), from._data()))
} // rules
template<class Fmpz>
inline typename mp::enable_if<traits::is_fmpzxx<Fmpz>, fmpz_factorxx>::type
factor_pp1(const Fmpz& f, ulong B1, ulong B2_sqrt, ulong c)
{
fmpz_factorxx res;
res.set_factor_pp1(f, B1, B2_sqrt, c);
return res;
}
inline void print(const fmpz_factorxx& f)
{
f.print();
}
} // flint
#endif