sequential Namespace Reference

Typedefs
using	nat_type = sigmaodd::nat_type
using	prime_type = sigmaodd::prime_type

Functions
std::set< nat_type >	sequential_check_gentle_varsigma_odd (nat_type first_n, nat_type last_n, bool print_bad=true)
	Check in the order all odd gentle numbers between first_n and last_n, and if print_bad then print all bad numbers between first_n and last_n (included). The consequence of the result is that: if (all numbers < first_n respect the conjecture) and (all perfect squares < last_n respect the conjecture) and (all bad numbers < last_n respect the conjecture) then all numbers < last_n respect the conjecture. More...
std::set< nat_type >	sequential_check_gentle_varsigma_odd (nat_type first_n, nat_type last_n, const std::set< nat_type > &bad_table, nat_type bad_first_n, nat_type bad_last_n, bool print_bad=true)
	Check in the order all odd gentle numbers between first_n and last_n, and if print_bad then print all bad numbers between first_n and last_n (included). The consequence of the result is that: if (all numbers < first_n respect the conjecture) and (all perfect squares < last_n respect the conjecture) and (all bad numbers < last_n respect the conjecture) then all numbers < last_n respect the conjecture. More...
void	sequential_check_varsigma_odd (nat_type first_n, nat_type last_n, bool print_bad=true, bool print_all=false, bool print_category=true, bool print_lower=true, bool print_length=true, bool print_path=true)
	Check in the order all odd numbers between first_n and last_n. The consequence of the result is that: if all numbers < first_n respect the conjecture and first_iterate_varsigma_odd_until_lower() do not exits with impossible to check or cycle found, then all numbers <= last_n respect the conjecture. More...
void	sequential_check_varsigma_odd_perfect_square (nat_type n, bool print=true, bool print_lower=true, bool print_length=true, bool print_path=true)
	Return sequential_check_varsigma_odd(), but only for n perfect square. More...
void	sequential_check_varsigma_odd_complete (nat_type first_n, nat_type last_n, bool check_useless=false, bool print_bad=true, bool print_all=false, bool print_category=true, bool print_lower=true, bool print_length=true, bool print_path=true)
	Check completely (until 1) in the order all odd numbers between first_n and last_n. The consequence of the result is that: all odd numbers checked between first_n and last_n (included) respect the conjecture. More...
void	sequential_check_varsigma_odd_perfect_square_complete (nat_type n, bool print=true, bool print_lower=true, bool print_length=true, bool print_path=true)
	Return sequential_check_varsigma_odd_complete(), but only for n perfect square. More...
bool	sequential_is_varsigma_odd_lower (nat_type n, const std::set< nat_type > &bad_table, nat_type bad_first_n)
	Return true iff varsigma_odd(n) < n. More...
bool	sequential_is_varsigma_odd_lower (nat_type n, const std::set< nat_type > &bad_table, nat_type bad_first_n, nat_type bad_last_n)
	Return true iff varsigma_odd(n) < n. More...
std::vector< nat_type >	sequential_iterate_varsigma_odd_until_1 (nat_type start_n)
	Iterate sequential_varsigma_odd(start_n) until to reach 1. Return this complete path. More...
std::vector< nat_type >	sequential_iterate_varsigma_odd_perfect_square_until_1 (nat_type start_n)
	Return sequential_iterate_varsigma_odd_until_1(), but only for n perfect square. More...
std::vector< nat_type >	sequential_iterate_varsigma_odd_until_lower (nat_type start_n)
	Iterate sequential_varsigma_odd(start_n) until to be have a result < start_n. Return this partial path. More...
std::vector< nat_type >	sequential_iterate_varsigma_odd_perfect_square_until_lower (nat_type start_n)
	Return sequential_iterate_varsigma_odd_until_lower(), but only for n perfect square. More...
std::vector< nat_type >	sequential_print_in_order (const std::set< nat_type > &ns)
	Print number from ns, in increasing order and return a list of these number in the same order. More...
nat_type	sequential_varsigma_odd (nat_type n)
	Return varsigma_odd(n), i.e. the sum of all odd divisors of n, divided by 2 until to be odd. More...
nat_type	sequential_varsigma_odd_perfect_square (nat_type n)
	Return sequential_varsigma_odd(), but only for n perfect square. More...
std::set< nat_type >	sequential_varsigma_odd_greater_set (const std::vector< nat_type > &ns, const std::set< nat_type > &bad_table, nat_type bad_first_n, nat_type bad_last_n)
	Return the set of n from ns such that varsigma_odd(n) > n. More...
constexpr nat_type	sequential_min_array (const nat_type ns[], size_t size)
	Return the minimum of the first size values of ns. More...
constexpr nat_type	sequential_sigma_odd_upper_bound (nat_type n, const std::set< nat_type > &bad_table, nat_type bad_first_n)
	Return an upper bound of varsigma_odd(n). More...
constexpr nat_type	sequential_sigma_odd_upper_bound (nat_type n, const std::set< nat_type > &bad_table, nat_type bad_first_n, nat_type bad_last_n)
	Return an upper bound of sigma_odd(n). More...
constexpr nat_type	sequential_sigma_odd_upper_bound_with_sqrt (nat_type n, const std::set< nat_type > &bad_table, nat_type bad_first_n, nat_type sqrt_n)
	Return an upper bound of varsigma_odd(n). More...
constexpr nat_type	sequential_sigma_odd_upper_bound_with_sqrt (nat_type n, const std::set< nat_type > &bad_table, nat_type bad_first_n, nat_type bad_last_n, nat_type sqrt_n)
	Return an upper bound of sigma_odd(n). More...

Typedef Documentation

nat_type

using sequential::nat_type = typedef sigmaodd::nat_type

Definition at line 26 of file sequential.hpp.

prime_type

using sequential::prime_type = typedef sigmaodd::prime_type

Definition at line 27 of file sequential.hpp.

Function Documentation

sequential_check_gentle_varsigma_odd() [1/2]

std::set< nat_type > sequential::sequential_check_gentle_varsigma_odd	(	nat_type	first_n,
		nat_type	last_n,
		bool	print_bad = true
	)

Check in the order all odd gentle numbers between first_n and last_n, and if print_bad then print all bad numbers between first_n and last_n (included). The consequence of the result is that: if (all numbers < first_n respect the conjecture) and (all perfect squares < last_n respect the conjecture) and (all bad numbers < last_n respect the conjecture) then all numbers < last_n respect the conjecture.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

first_n	3 <= odd <= last_n
last_n	<= MAX_POSSIBLE_N
print_bad

Returns

the set of all bad numbers between first_n and last_n (included)

Definition at line 29 of file sequential.cpp.

sequential_check_gentle_varsigma_odd() [2/2]

std::set< nat_type > sequential::sequential_check_gentle_varsigma_odd	(	nat_type	first_n,
		nat_type	last_n,
		const std::set< nat_type > &	bad_table,
		nat_type	bad_first_n,
		nat_type	bad_last_n,
		bool	print_bad = true
	)

Check in the order all odd gentle numbers between first_n and last_n, and if print_bad then print all bad numbers between first_n and last_n (included). The consequence of the result is that: if (all numbers < first_n respect the conjecture) and (all perfect squares < last_n respect the conjecture) and (all bad numbers < last_n respect the conjecture) then all numbers < last_n respect the conjecture.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

first_n	3 <= odd <= last_n
last_n	<= MAX_POSSIBLE_N
bad_table	must be contains all bad numbers between bad_first_n and bad_last_n (included)
bad_first_n
bad_last_n
print_bad

Returns

the set of all bad numbers between first_n and last_n (included)

Definition at line 61 of file sequential.cpp.

sequential_check_varsigma_odd()

void sequential::sequential_check_varsigma_odd	(	nat_type	first_n,
		nat_type	last_n,
		bool	print_bad = true,
		bool	print_all = false,
		bool	print_category = true,
		bool	print_lower = true,
		bool	print_length = true,
		bool	print_path = true
	)

Check in the order all odd numbers between first_n and last_n. The consequence of the result is that: if all numbers < first_n respect the conjecture and first_iterate_varsigma_odd_until_lower() do not exits with impossible to check or cycle found, then all numbers <= last_n respect the conjecture.

If print_bad then print all bad numbers between first_n and last_n (included).

If print_all then print all odd numbers between first_n and last_n (included).

If print_category then moreover print the category of the number.

If print_lower then moreover print the lower number reached.

If print_length then moreover print the length of the partial path.

If print_path then moreover print the partial path.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

first_n	3 <= odd <= last_n
last_n	<= MAX_POSSIBLE_N
print_bad
print_all
print_category
print_length
print_lower
print_path

Definition at line 95 of file sequential.cpp.

sequential_check_varsigma_odd_complete()

void sequential::sequential_check_varsigma_odd_complete	(	nat_type	first_n,
		nat_type	last_n,
		bool	check_useless = false,
		bool	print_bad = true,
		bool	print_all = false,
		bool	print_category = true,
		bool	print_lower = true,
		bool	print_length = true,
		bool	print_path = true
	)

Check completely (until 1) in the order all odd numbers between first_n and last_n. The consequence of the result is that: all odd numbers checked between first_n and last_n (included) respect the conjecture.

If check_useless then check also odd numbers that verify is_first_mersenne_prime_unitary_divide(n) else check only others.

If print_bad then print all bad numbers between first_n and last_n (included).

If print_all then print all odd numbers between first_n and last_n (included).

If print_category then moreover print the category of the number.

If print_lower then moreover print the lower number reached.

If print_length then moreover print the length of the partial path.

If print_path then moreover print the partial path.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

first_n	3 <= odd <= last_n
last_n	<= MAX_POSSIBLE_N
check_useless
print_bad
print_all
print_category
print_length
print_lower
print_path

Definition at line 148 of file sequential.cpp.

sequential_check_varsigma_odd_perfect_square()

void sequential::sequential_check_varsigma_odd_perfect_square	(	nat_type	n,
		bool	print = true,
		bool	print_lower = true,
		bool	print_length = true,
		bool	print_path = true
	)

Return sequential_check_varsigma_odd(), but only for n perfect square.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

n	3 <= odd <= MAX_POSSIBLE_N
print
print_length
print_lower
print_path

Definition at line 124 of file sequential.cpp.

sequential_check_varsigma_odd_perfect_square_complete()

void sequential::sequential_check_varsigma_odd_perfect_square_complete	(	nat_type	n,
		bool	print = true,
		bool	print_lower = true,
		bool	print_length = true,
		bool	print_path = true
	)

Return sequential_check_varsigma_odd_complete(), but only for n perfect square.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

n	3 <= odd <= MAX_POSSIBLE_N
print
print_length
print_lower
print_path

Definition at line 179 of file sequential.cpp.

sequential_is_varsigma_odd_lower() [1/2]

bool sequential::sequential_is_varsigma_odd_lower	(	nat_type	n,
		const std::set< nat_type > &	bad_table,
		nat_type	bad_first_n
	)

Return true iff varsigma_odd(n) < n.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

n	3 <= odd <= MAX_POSSIBLE_N
bad_table	must be contains all bad numbers between first_n (included) and n (excluded)
bad_first_n

Definition at line 202 of file sequential.cpp.

sequential_is_varsigma_odd_lower() [2/2]

bool sequential::sequential_is_varsigma_odd_lower	(	nat_type	n,
		const std::set< nat_type > &	bad_table,
		nat_type	bad_first_n,
		nat_type	bad_last_n
	)

Return true iff varsigma_odd(n) < n.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

n	3 <= odd <= MAX_POSSIBLE_N
bad_table	must be contains all bad numbers between bad_first_n and bad_last_n (included)
bad_first_n
bad_last_n

Definition at line 253 of file sequential.cpp.

sequential_iterate_varsigma_odd_perfect_square_until_1()

std::vector< nat_type > sequential::sequential_iterate_varsigma_odd_perfect_square_until_1

(

nat_type

start_n

)

Return sequential_iterate_varsigma_odd_until_1(), but only for n perfect square.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

start_n

3 <= odd <= MAX_POSSIBLE_N

Definition at line 345 of file sequential.cpp.

sequential_iterate_varsigma_odd_perfect_square_until_lower()

std::vector< nat_type > sequential::sequential_iterate_varsigma_odd_perfect_square_until_lower

(

nat_type

start_n

)

Return sequential_iterate_varsigma_odd_until_lower(), but only for n perfect square.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

start_n

3 <= odd <= MAX_POSSIBLE_N

Definition at line 433 of file sequential.cpp.

sequential_iterate_varsigma_odd_until_1()

std::vector< nat_type > sequential::sequential_iterate_varsigma_odd_until_1

(

nat_type

start_n

)

Iterate sequential_varsigma_odd(start_n) until to reach 1. Return this complete path.

If one iteration gives a result > MAX_POSSIBLE_N then exits with an error message "! Impossible to check [...]".

If one cycle is reached then exits with an error message "! Found not trivial cycle [...]".

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

start_n

3 <= odd <= MAX_POSSIBLE_N

Definition at line 304 of file sequential.cpp.

sequential_iterate_varsigma_odd_until_lower()

std::vector< nat_type > sequential::sequential_iterate_varsigma_odd_until_lower

(

nat_type

start_n

)

Iterate sequential_varsigma_odd(start_n) until to be have a result < start_n. Return this partial path.

If one iteration gives a result > MAX_POSSIBLE_N then exits with an error message "! Impossible to check [...]".

If one cycle is reached then exits with an error message "! Found not trivial cycle [...]".

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

start_n

3 <= odd <= MAX_POSSIBLE_N

Definition at line 392 of file sequential.cpp.

sequential_min_array()

constexpr nat_type sequential::sequential_min_array	(	const nat_type	ns[],
		size_t	size
	)

Return the minimum of the first size values of ns.

Parameters

ns	must be contains at least size elements
size	>= 1

Definition at line 29 of file sequential__inline.hpp.

sequential_print_in_order()

std::vector< nat_type > sequential::sequential_print_in_order

(

const std::set< nat_type > &

ns

)

Print number from ns, in increasing order and return a list of these number in the same order.

Definition at line 480 of file sequential.cpp.

sequential_sigma_odd_upper_bound() [1/2]

constexpr nat_type sequential::sequential_sigma_odd_upper_bound	(	nat_type	n,
		const std::set< nat_type > &	bad_table,
		nat_type	bad_first_n
	)

Return an upper bound of varsigma_odd(n).

If n == 1 then return 1. If n is identified as a gentle number then return n - 1. Else return floor((n * ceil(2 * (n - 1)^{1/8} + 1)) / 2).

Parameters

n	odd
bad_table	must be contains all bad numbers between bad_first_n (included) and n (excluded)
bad_first_n

Definition at line 44 of file sequential__inline.hpp.

sequential_sigma_odd_upper_bound() [2/2]

constexpr nat_type sequential::sequential_sigma_odd_upper_bound	(	nat_type	n,
		const std::set< nat_type > &	bad_table,
		nat_type	bad_first_n,
		nat_type	bad_last_n
	)

Return an upper bound of sigma_odd(n).

If n == 1 then return 1. If n is identified as a gentle number then return n - 1. Else return floor((n * ceil(2 * (n - 1)^{1/8} + 1)) / 2).

Parameters

n	odd
bad_table	must be contains all bad numbers between bad_first_n and bad_last_n (included)
bad_first_n
bad_last_n

Definition at line 60 of file sequential__inline.hpp.

sequential_sigma_odd_upper_bound_with_sqrt() [1/2]

constexpr nat_type sequential::sequential_sigma_odd_upper_bound_with_sqrt	(	nat_type	n,
		const std::set< nat_type > &	bad_table,
		nat_type	bad_first_n,
		nat_type	sqrt_n
	)

Return an upper bound of varsigma_odd(n).

If n == 1 then return 1. If n is identified as a gentle number then return n - 1. Else return floor((n * ceil(2 * (n - 1)^{1/8} + 1)) / 2).

Parameters

n	odd
bad_table	must be contains all bad numbers between bad_first_n (included) and n (excluded)
bad_first_n
sqrt_n	must be equal floor_square_root(n)

Definition at line 76 of file sequential__inline.hpp.

sequential_sigma_odd_upper_bound_with_sqrt() [2/2]

constexpr nat_type sequential::sequential_sigma_odd_upper_bound_with_sqrt	(	nat_type	n,
		const std::set< nat_type > &	bad_table,
		nat_type	bad_first_n,
		nat_type	bad_last_n,
		nat_type	sqrt_n
	)

Return an upper bound of sigma_odd(n).

If n == 1 then return 1. If n is identified as a gentle number then return n - 1. Else return floor((n * ceil(2 * (n - 1)^{1/8} + 1)) / 2).

Parameters

n	odd
bad_table	must be contains all bad numbers between bad_first_n and bad_last_n (included)
bad_first_n
bad_last_n
sqrt_n	must be equal floor_square_root(n)

Definition at line 94 of file sequential__inline.hpp.

sequential_varsigma_odd()

nat_type sequential::sequential_varsigma_odd

(

nat_type

n

)

Return varsigma_odd(n), i.e. the sum of all odd divisors of n, divided by 2 until to be odd.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

n	3 <= odd <= MAX_POSSIBLE_N

Definition at line 494 of file sequential.cpp.

sequential_varsigma_odd_greater_set()

std::set< nat_type > sequential::sequential_varsigma_odd_greater_set	(	const std::vector< nat_type > &	ns,
		const std::set< nat_type > &	bad_table,
		nat_type	bad_first_n,
		nat_type	bad_last_n
	)

Return the set of n from ns such that varsigma_odd(n) > n.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

ns	list of (3 <= odd <= MAX_POSSIBLE_N)
bad_table	must be contains all bad numbers between bad_first_n and bad_last_n (included)
bad_first_n
bad_last_n

Definition at line 588 of file sequential.cpp.

sequential_varsigma_odd_perfect_square()

nat_type sequential::sequential_varsigma_odd_perfect_square

(

nat_type

n

)

Return sequential_varsigma_odd(), but only for n perfect square.

sigmaodd::primes.cpp must be compiled without the macro PRIME16.

Parameters

n	3 <= (odd and perfect square) <= MAX_POSSIBLE_N

Definition at line 536 of file sequential.cpp.