Reorganizing files & folders to prepaper for modularization

[jfalcou]

Objectives

Even if modules are still far in the future, we want to prepare ourselves. The idea is to clearly identify a subset of EVE code that makes sense as a module. The main idea is to not be too fine-grained to not end up with a myriad of inter modules dependencies AND not be too coarse either.

Current Idea

We are going to reorder files so that :

• Make it so include/eve/module actually contains file per module instead of just the real folder
• Reorder tests and documentation structure following those changes
• Keep include/eve/functions/* as our current access to functions
• Add include/eve/module/<name>/name.hpp files to include everything in a module. Those file will then later become module definitions

Projection into modules

Main plan

The planned module structure is:

• import eve for all the basic types, operators, and traits
• import eve.math for all the <cmath> level functions
• import eve.<module_name> for all other modules

What are we going to do with pedantic etc?

Either we don't do anything cause modules to precompile everything turbo fast or one can imagine import eve::module::pedantic to access the pedantic version of a module. We may end up having no choice depending on the dependences of pedantic versions.

What about the complex dilemma

import eve.complex is a no-brainer. Now, where should the complex version of Bessel functions live?

Current idea:
import eve.bessel.complex

Tasks at hand

• @jfalcou will extract an elliptic and Bessel module out of special/. No function depends on them, so they can safely be modularized
• @jtlap will analyze other groups of functions and decide on how they should be modularized

Open Questions

• is algorithm a module or in core ?

[jtlap]

for me algorithm is definitely a module:

1. it makes an intensive use of the EVE SIMD core (meaning wide class and their basic arithmetic and logic operations)
2. it conveys no peculiar mathematical floating point semantic (other than algebraic for some of the algorithms: commutativity,
   associativity...)
3. it has a global and simple and well known meaning related to the STL
4. is used by no other module

[jtlap]

"Résumé brutal": eve::algorthm is using SIMD with ranges

[jtlap]

reordered
//////////////////////////////////
old groupings
//////////////////////////////////
algorithm.hpp
allfiles.hpp
arithmetic.hpp
combinatorial.hpp
elliptic.hpp
exponentials.hpp
factorial.hpp
fuzzy.hpp
horizontal.hpp
hyperbolic.hpp
ieee754.hpp
inverse_hyperbolic.hpp
invtrigonometric.hpp
operator.hpp
plus.hpp
polynomial.hpp
predicate.hpp
proba.hpp
reduction.hpp
special.hpp
swar.hpp
trigonometric.hpp
/////////////////////////////////////////////////////////
uncertain
/////////////////////////////////////////////////////////
compress_store.hpp ??_core
musl.hpp ??_decorator used by log
plain.hpp ??_decorator
numeric.hpp ??_decorator
regular.hpp ??_decorator
pedantic.hpp ??_decorator
saturated.hpp ??_decorator
scan.hpp ??_algorithm
fibonacci.hpp ??_combinatorial
zip.hpp ??_algorithm
/////////////////////////////////////////////////////////
bessel
/////////////////////////////////////////////////////////
airy.hpp bessel
airy_ai.hpp bessel
airy_bi.hpp bessel
cyl_bessel_i0.hpp bessel
cyl_bessel_i1.hpp bessel
cyl_bessel_in.hpp bessel
cyl_bessel_j0.hpp bessel
cyl_bessel_j1.hpp bessel
cyl_bessel_jn.hpp bessel
cyl_bessel_k0.hpp bessel
cyl_bessel_k1.hpp bessel
cyl_bessel_kn.hpp bessel
cyl_bessel_y0.hpp bessel
cyl_bessel_y1.hpp bessel
cyl_bessel_yn.hpp bessel
/////////////////////////////////////////////////////////
combinatorial
/////////////////////////////////////////////////////////
gcd.hpp combinatorial
lcm.hpp combinatorial
nth_prime.hpp combinatorial
prime_ceil.hpp combinatorial
bernouilli.hpp combinatorial
lfactorial.hpp combinatorial
prime_floor.hpp combinatorial
double_factorial.hpp combinatorial
/////////////////////////////////////////////////////////
core
/////////////////////////////////////////////////////////
hi.hpp core
lo.hpp core
raw.hpp core
rec.hpp core
rem.hpp core
shl.hpp core
shr.hpp core
sqr.hpp core
sub.hpp core
abs.hpp core
add.hpp core
all.hpp core
any.hpp core
dec.hpp core
div.hpp core
ffs.hpp core
fls.hpp core
inc.hpp core
max.hpp core
min.hpp core
mul.hpp core
none.hpp core
read.hpp core
rotl.hpp core
rotr.hpp core
rshl.hpp core
rshr.hpp core
safe.hpp core
sign.hpp core
bits.hpp core
ceil.hpp core
dist.hpp core
fdim.hpp core
fmod.hpp core
frac.hpp core
lerp.hpp core
load.hpp core
lohi.hpp core
modf.hpp core
round.hpp core
splat.hpp core
sqrt.hpp core
store.hpp core
trunc.hpp core
write.hpp core
clamp.hpp core
floor.hpp core
hypot.hpp core
minus.hpp core
reduce.hpp core
remdiv.hpp core
signnz.hpp core
unsafe.hpp core
absmax.hpp core
absmin.hpp core
bit_or.hpp core
gather.hpp core
ifrexp.hpp core
is_eqz.hpp core
is_gez.hpp core
is_gtz.hpp core
is_lez.hpp core
is_ltz.hpp core
is_nez.hpp core
is_odd.hpp core
lookup.hpp core
maxabs.hpp core
maxmag.hpp core
memory.hpp core
minabs.hpp core
minmag.hpp core
negate.hpp core
replace.hpp core
reverse.hpp core
shuffle.hpp core
swap_if.hpp core
average.hpp core
bit_and.hpp core
bit_not.hpp core
bit_shl.hpp core
bit_shr.hpp core
bit_xor.hpp core
combine.hpp core
convert.hpp core
if_else.hpp core
is_even.hpp core
is_less.hpp core
is_pow2.hpp core
logical.hpp core
maximum.hpp core
minimum.hpp core
nearest.hpp core
oneminus.hpp core
popcount.hpp core
rounding.hpp core
saturate.hpp core
binarize.hpp core
bit_cast.hpp core
bit_ceil.hpp core
bit_mask.hpp core
is_equal.hpp core
negatenz.hpp core
remainder.hpp core
roundings.hpp core
shuffling.hpp core
slice_low.hpp core
swapbytes.hpp core
bit_floor.hpp core
bit_notor.hpp core
bitofsign.hpp core
bit_ornot.hpp core
bit_width.hpp core
broadcast.hpp core
converter.hpp core
decorator.hpp core
manhattan.hpp core
nb_values.hpp core
negabsmax.hpp core
negabsmin.hpp core
negmaxabs.hpp core
negminabs.hpp core
refine_rec.hpp core (detail ?)
roundscale.hpp core
slice_high.hpp core
slide_left.hpp core
bit_andnot.hpp core
bit_notand.hpp core
bit_select.hpp core
comparison.hpp core
conversion.hpp core
countl_one.hpp core
countr_one.hpp core
count_true.hpp core
derivative.hpp core
first_true.hpp core
ifnot_else.hpp core
interleave.hpp core
is_greater.hpp core
logical_or.hpp core
slide_right.hpp core
comparisons.hpp core
countl_zero.hpp core
countr_zero.hpp core
firstbitset.hpp core
is_denormal.hpp core
is_infinite.hpp core
logical_and.hpp core
logical_not.hpp core
logical_xor.hpp core
binarize_not.hpp core
is_not_equal.hpp core
firstbitunset.hpp core
is_less_equal.hpp core
logical_notor.hpp core
logical_ornot.hpp core
has_single_bit.hpp core
is_lessgreater.hpp core
is_not_greater.hpp core
logical_andnot.hpp core
logical_notand.hpp core
broadcast_group.hpp core
is_greater_equal.hpp core
is_not_less_equal.hpp core
interleave_shuffle.hpp core
swap_adjacent_groups.hpp core
is_not_greater_equal.hpp core
/////////////////////////////////////////////////////////
elliptic
/////////////////////////////////////////////////////////
ellint_1.hpp elliptic
ellint_2.hpp elliptic
ellint_d.hpp elliptic
ellint_rc.hpp elliptic
ellint_rd.hpp elliptic
ellint_rf.hpp elliptic
ellint_rg.hpp elliptic
ellint_rj.hpp elliptic
/////////////////////////////////////////////////////////
euler
/////////////////////////////////////////////////////////
erf.hpp euler
beta.hpp euler
erfc.hpp euler
erfcx.hpp euler
lbeta.hpp euler
tgamma.hpp euler
lgamma.hpp euler
signgam.hpp euler
betainc.hpp euler
erf_inv.hpp euler
gamma_p.hpp euler
stirling.hpp euler
erfc_inv.hpp euler
betainc_inv.hpp euler
gamma_p_inv.hpp euler
rising_factorial.hpp euler
lrising_factorial.hpp euler
/////////////////////////////////////////////////////////
math
/////////////////////////////////////////////////////////
pow.hpp math
rat.hpp math
sec.hpp math
sin.hpp math
tan.hpp math
arg.hpp math
cos.hpp math
cot.hpp math
csc.hpp math
exp.hpp math
fam.hpp math
fma.hpp math
fms.hpp math
fsm.hpp math
log.hpp math
secd.hpp math
sech.hpp math
sinc.hpp math
sind.hpp math
sinh.hpp math
tand.hpp math
tanh.hpp math
acot.hpp math
acsc.hpp math
asec.hpp math
asin.hpp math
atan.hpp math
cbrt.hpp math
conj.hpp math
cosd.hpp math
cosh.hpp math
cotd.hpp math
coth.hpp math
cscd.hpp math
csch.hpp math
exp2.hpp math
fanm.hpp math
fnma.hpp math
fnms.hpp math
fsnm.hpp math
log2.hpp math
pow1p.hpp math
powm1.hpp math
rsqrt.hpp math
secpi.hpp math
sinhc.hpp math
sinpi.hpp math
tanpi.hpp math
acosd.hpp math
acosh.hpp math
acos.hppp math
acotd.hpp math
acoth.hpp math
acscd.hpp math
acsch.hpp math
asecd.hpp math
asech.hpp math
asind.hpp math
asinh.hpp math
atan2.hpp math
atand.hpp math
atanh.hpp math
cospi.hpp math
cotpi.hpp math
cscpi.hpp math
exp10.hpp math
expm1.hpp math
expx2.hpp math
log10.hpp math
log1p.hpp math
sincos.hpp math
sincpi.hpp math
sinpic.hpp math
acospi.hpp math
acotpi.hpp math
acscpi.hpp math
asecpi.hpp math
asinpi.hpp math
atan2d.hpp math
atanpi.hpp math
lpnorm.hpp math
nthroot.hpp math
pow_abs.hpp math
radinpi.hpp math
rempio2.hpp math
sincosd.hpp math
sqr_abs.hpp math
atan2pi.hpp math
div_180.hpp math
epsilon.hpp math
log_abs.hpp math
quadrant.hpp math
radindeg.hpp math
rem_pio2.hpp math
sindcosd.hpp math
sinhcosh.hpp math
copysign.hpp math
deginrad.hpp math
geommean.hpp math
fracscale.hpp math
sinpicospi.hpp math
trigo_tags.hpp math
significants.hpp math
logspace_add.hpp math
logspace_sub.hpp math
reverse_horner.hpp math
/////////////////////////////////////////////////////////
math or ieee
/////////////////////////////////////////////////////////
next.hpp math_or_ieee
prev.hpp math_or_ieee
frexp.hpp math_or_ieee
ldexp.hpp math_or_ieee
is_nan.hpp math_or_ieee
two_add.hpp math_or_ieee
ulpdist.hpp math_or_ieee
is_imag.hpp math_or_ieee
is_ngez.hpp math_or_ieee
is_ngtz.hpp math_or_ieee
is_nlez.hpp math_or_ieee
is_nltz.hpp math_or_ieee
is_real.hpp math_or_ieee
two_prod.hpp math_or_ieee
exponent.hpp math_or_ieee
is_flint.hpp math_or_ieee
mantissa.hpp math_or_ieee
nextafter.hpp math_or_ieee
two_split.hpp math_or_ieee
is_finite.hpp math_or_ieee
is_normal.hpp math_or_ieee
is_not_nan.hpp math_or_ieee
is_ordered.hpp math_or_ieee
is_negative.hpp math_or_ieee
is_not_imag.hpp math_or_ieee
is_not_less.hpp math_or_ieee
is_not_real.hpp math_or_ieee
is_positive.hpp math_or_ieee
is_not_flint.hpp math_or_ieee
is_unordered.hpp math_or_ieee
is_not_finite.hpp math_or_ieee
is_not_denormal.hpp math_or_ieee
is_not_infinite.hpp math_or_ieee
/////////////////////////////////////////////////////////
polynomial
/////////////////////////////////////////////////////////
p_kind.hpp polynomial decorator used by legendre
q_kind.hpp polynomial decorator used by legendre
horner.hpp polynomial
newton.hpp polynomial
hermite.hpp polynomial
laguerre.hpp polynomial
legendre.hpp polynomial
gegenbauer.hpp polynomial
/////////////////////////////////////////////////////////
proba
/////////////////////////////////////////////////////////
ev_distribution.hpp proba
gamma_distribution.hpp proba
normal_distribution.hpp proba
cauchy_distribution.hpp proba
poisson_distribution.hpp proba
binomial_distribution.hpp proba
lognormal_distribution.hpp proba
uniform_discrete_distribution.hpp proba
exponential_distribution.hpp proba
uniform_continuous_distribution.hpp proba
/////////////////////////////////////////////////////////
special
/////////////////////////////////////////////////////////
zeta.hpp special
dawson.hpp special
digamma.hpp special
exp_int.hpp special

[DenisYaroshevskiy]

I don't think we know anything about modules yet.

I'd personally go with logical splits of files, which is not necessary works well due to a heavy use of operators (like swizzle with an operator).

algo is definetly a module.
Also I keep thinking that maybe iterator concept needs to leave in eve so that for example compress store can be expressed as store