Copy disabled (too large)
Download .txt
Showing preview only (37,813K chars total). Download the full file to get everything.
Repository: mhogrefe/malachite
Branch: master
Commit: 9fd25828c9ab
Files: 2707
Total size: 35.5 MB
Directory structure:
gitextract_3ecze51d/
├── .envrc
├── .github/
│ ├── FUNDING.yml
│ └── workflows/
│ └── rust.yml
├── .gitignore
├── .vscode/
│ ├── launch.json
│ └── tasks.json
├── COPYING
├── COPYING.LESSER
├── Cargo.toml
├── LICENSE
├── README.md
├── _config.yml
├── additional-lints.py
├── build.sh
├── docs/
│ ├── CNAME
│ ├── _config.yml
│ ├── _includes/
│ │ └── head-custom.html
│ ├── _layouts/
│ │ └── post.html
│ ├── _posts/
│ │ ├── 2022-06-05-1-intro.md
│ │ ├── 2022-06-05-2-exhaustive.md
│ │ ├── 2022-07-03-exhaustive.md
│ │ └── 2022-07-30-denominators.md
│ ├── assets/
│ │ ├── denominators/
│ │ │ ├── gap-and-bound-graph.asy
│ │ │ ├── gap-graph.asy
│ │ │ ├── gaps.asy
│ │ │ ├── j-graph.asy
│ │ │ └── sixths.asy
│ │ ├── exhaustive-part-2/
│ │ │ ├── cantor-graph.asy
│ │ │ ├── cantor-grid.asy
│ │ │ ├── cantor-large.tex
│ │ │ ├── cantor-triples-large.tex
│ │ │ ├── interleave-bits-1.tex
│ │ │ ├── interleave-bits-2.tex
│ │ │ ├── interleave-grid-filtered.asy
│ │ │ ├── interleave-grid.asy
│ │ │ ├── interleave-large.tex
│ │ │ ├── interleave-pairs-graph.asy
│ │ │ ├── interleave-triples-bits.tex
│ │ │ ├── interleave-triples-graph.asy
│ │ │ └── interleave-triples-large.tex
│ │ └── logo.asy
│ ├── index.md
│ └── performance.md
├── find_replace.py
├── flake.nix
├── katex-header.html
├── malachite/
│ ├── Cargo.toml
│ ├── katex-header.html
│ └── src/
│ └── lib.rs
├── malachite-base/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── README.md
│ ├── katex-header.html
│ ├── rustfmt.toml
│ ├── src/
│ │ ├── bin.rs
│ │ ├── bin_util/
│ │ │ ├── demo_and_bench/
│ │ │ │ ├── bools/
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── not_assign.rs
│ │ │ │ ├── chars/
│ │ │ │ │ ├── crement/
│ │ │ │ │ │ ├── char_to_contiguous_range.rs
│ │ │ │ │ │ ├── contiguous_range_to_char.rs
│ │ │ │ │ │ ├── crement.rs
│ │ │ │ │ │ └── mod.rs
│ │ │ │ │ └── mod.rs
│ │ │ │ ├── comparison/
│ │ │ │ │ ├── macros.rs
│ │ │ │ │ └── mod.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── num/
│ │ │ │ │ ├── arithmetic/
│ │ │ │ │ │ ├── abs.rs
│ │ │ │ │ │ ├── abs_diff.rs
│ │ │ │ │ │ ├── add_mul.rs
│ │ │ │ │ │ ├── arithmetic_checked_shl.rs
│ │ │ │ │ │ ├── arithmetic_checked_shr.rs
│ │ │ │ │ │ ├── binomial_coefficient.rs
│ │ │ │ │ │ ├── ceiling.rs
│ │ │ │ │ │ ├── checked_add_mul.rs
│ │ │ │ │ │ ├── checked_square.rs
│ │ │ │ │ │ ├── checked_sub_mul.rs
│ │ │ │ │ │ ├── coprime_with.rs
│ │ │ │ │ │ ├── div_exact.rs
│ │ │ │ │ │ ├── div_mod.rs
│ │ │ │ │ │ ├── div_round.rs
│ │ │ │ │ │ ├── divisible_by.rs
│ │ │ │ │ │ ├── divisible_by_power_of_2.rs
│ │ │ │ │ │ ├── eq_mod.rs
│ │ │ │ │ │ ├── eq_mod_power_of_2.rs
│ │ │ │ │ │ ├── extended_gcd.rs
│ │ │ │ │ │ ├── factorial.rs
│ │ │ │ │ │ ├── floor.rs
│ │ │ │ │ │ ├── gcd.rs
│ │ │ │ │ │ ├── is_power_of_2.rs
│ │ │ │ │ │ ├── kronecker_symbol.rs
│ │ │ │ │ │ ├── lcm.rs
│ │ │ │ │ │ ├── log_base.rs
│ │ │ │ │ │ ├── log_base_2.rs
│ │ │ │ │ │ ├── log_base_power_of_2.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── mod_add.rs
│ │ │ │ │ │ ├── mod_inverse.rs
│ │ │ │ │ │ ├── mod_is_reduced.rs
│ │ │ │ │ │ ├── mod_mul.rs
│ │ │ │ │ │ ├── mod_neg.rs
│ │ │ │ │ │ ├── mod_op.rs
│ │ │ │ │ │ ├── mod_pow.rs
│ │ │ │ │ │ ├── mod_power_of_2.rs
│ │ │ │ │ │ ├── mod_power_of_2_add.rs
│ │ │ │ │ │ ├── mod_power_of_2_inverse.rs
│ │ │ │ │ │ ├── mod_power_of_2_is_reduced.rs
│ │ │ │ │ │ ├── mod_power_of_2_mul.rs
│ │ │ │ │ │ ├── mod_power_of_2_neg.rs
│ │ │ │ │ │ ├── mod_power_of_2_pow.rs
│ │ │ │ │ │ ├── mod_power_of_2_shl.rs
│ │ │ │ │ │ ├── mod_power_of_2_shr.rs
│ │ │ │ │ │ ├── mod_power_of_2_square.rs
│ │ │ │ │ │ ├── mod_power_of_2_sub.rs
│ │ │ │ │ │ ├── mod_shl.rs
│ │ │ │ │ │ ├── mod_shr.rs
│ │ │ │ │ │ ├── mod_square.rs
│ │ │ │ │ │ ├── mod_sub.rs
│ │ │ │ │ │ ├── neg.rs
│ │ │ │ │ │ ├── next_power_of_2.rs
│ │ │ │ │ │ ├── overflowing_abs.rs
│ │ │ │ │ │ ├── overflowing_add.rs
│ │ │ │ │ │ ├── overflowing_add_mul.rs
│ │ │ │ │ │ ├── overflowing_div.rs
│ │ │ │ │ │ ├── overflowing_mul.rs
│ │ │ │ │ │ ├── overflowing_neg.rs
│ │ │ │ │ │ ├── overflowing_pow.rs
│ │ │ │ │ │ ├── overflowing_square.rs
│ │ │ │ │ │ ├── overflowing_sub.rs
│ │ │ │ │ │ ├── overflowing_sub_mul.rs
│ │ │ │ │ │ ├── parity.rs
│ │ │ │ │ │ ├── pow.rs
│ │ │ │ │ │ ├── power_of_2.rs
│ │ │ │ │ │ ├── primorial.rs
│ │ │ │ │ │ ├── reciprocal.rs
│ │ │ │ │ │ ├── root.rs
│ │ │ │ │ │ ├── rotate.rs
│ │ │ │ │ │ ├── round_to_multiple.rs
│ │ │ │ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ │ │ │ ├── saturating_abs.rs
│ │ │ │ │ │ ├── saturating_add.rs
│ │ │ │ │ │ ├── saturating_add_mul.rs
│ │ │ │ │ │ ├── saturating_mul.rs
│ │ │ │ │ │ ├── saturating_neg.rs
│ │ │ │ │ │ ├── saturating_pow.rs
│ │ │ │ │ │ ├── saturating_square.rs
│ │ │ │ │ │ ├── saturating_sub.rs
│ │ │ │ │ │ ├── saturating_sub_mul.rs
│ │ │ │ │ │ ├── shl_round.rs
│ │ │ │ │ │ ├── shr_round.rs
│ │ │ │ │ │ ├── sign.rs
│ │ │ │ │ │ ├── sqrt.rs
│ │ │ │ │ │ ├── square.rs
│ │ │ │ │ │ ├── sub_mul.rs
│ │ │ │ │ │ ├── wrapping_abs.rs
│ │ │ │ │ │ ├── wrapping_add.rs
│ │ │ │ │ │ ├── wrapping_add_mul.rs
│ │ │ │ │ │ ├── wrapping_div.rs
│ │ │ │ │ │ ├── wrapping_mul.rs
│ │ │ │ │ │ ├── wrapping_neg.rs
│ │ │ │ │ │ ├── wrapping_pow.rs
│ │ │ │ │ │ ├── wrapping_square.rs
│ │ │ │ │ │ ├── wrapping_sub.rs
│ │ │ │ │ │ ├── wrapping_sub_mul.rs
│ │ │ │ │ │ ├── x_mul_y_to_zz.rs
│ │ │ │ │ │ ├── xx_add_yy_to_zz.rs
│ │ │ │ │ │ ├── xx_div_mod_y_to_qr.rs
│ │ │ │ │ │ ├── xx_sub_yy_to_zz.rs
│ │ │ │ │ │ ├── xxx_add_yyy_to_zzz.rs
│ │ │ │ │ │ ├── xxx_sub_yyy_to_zzz.rs
│ │ │ │ │ │ └── xxxx_add_yyyy_to_zzzz.rs
│ │ │ │ │ ├── comparison/
│ │ │ │ │ │ ├── cmp_abs.rs
│ │ │ │ │ │ ├── eq_abs.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ └── ord_abs_comparators.rs
│ │ │ │ │ ├── conversion/
│ │ │ │ │ │ ├── digits/
│ │ │ │ │ │ │ ├── general_digits/
│ │ │ │ │ │ │ │ ├── from_digits.rs
│ │ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ │ └── to_digits.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ └── power_of_2_digits/
│ │ │ │ │ │ │ ├── from_power_of_2_digits.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ ├── power_of_2_digit_iterable.rs
│ │ │ │ │ │ │ └── to_power_of_2_digits.rs
│ │ │ │ │ │ ├── from/
│ │ │ │ │ │ │ ├── convertible_from.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ ├── overflowing_from.rs
│ │ │ │ │ │ │ ├── rounding_from.rs
│ │ │ │ │ │ │ ├── saturating_from.rs
│ │ │ │ │ │ │ ├── try_from_and_exact_from.rs
│ │ │ │ │ │ │ └── wrapping_from.rs
│ │ │ │ │ │ ├── half/
│ │ │ │ │ │ │ ├── join_halves.rs
│ │ │ │ │ │ │ ├── lower_half.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ ├── split_in_half.rs
│ │ │ │ │ │ │ └── upper_half.rs
│ │ │ │ │ │ ├── is_integer.rs
│ │ │ │ │ │ ├── mantissa_and_exponent/
│ │ │ │ │ │ │ ├── integer_mantissa_and_exponent.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ ├── raw_mantissa_and_exponent.rs
│ │ │ │ │ │ │ └── sci_mantissa_and_exponent.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── slice/
│ │ │ │ │ │ │ ├── from_other_type_slice.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ ├── vec_from_other_type.rs
│ │ │ │ │ │ │ └── vec_from_other_type_slice.rs
│ │ │ │ │ │ └── string/
│ │ │ │ │ │ ├── from_sci_string.rs
│ │ │ │ │ │ ├── from_string.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── options/
│ │ │ │ │ │ │ ├── from_sci_string_options.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ ├── sci_size_options.rs
│ │ │ │ │ │ │ └── to_sci_options.rs
│ │ │ │ │ │ ├── to_sci.rs
│ │ │ │ │ │ └── to_string.rs
│ │ │ │ │ ├── factorization/
│ │ │ │ │ │ ├── factor.rs
│ │ │ │ │ │ ├── is_power.rs
│ │ │ │ │ │ ├── is_prime.rs
│ │ │ │ │ │ ├── is_square.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── prime_sieve.rs
│ │ │ │ │ │ ├── primes.rs
│ │ │ │ │ │ └── primitive_root_prime.rs
│ │ │ │ │ ├── float/
│ │ │ │ │ │ ├── basic/
│ │ │ │ │ │ │ ├── abs_negative_zero.rs
│ │ │ │ │ │ │ ├── from_ordered_representation.rs
│ │ │ │ │ │ │ ├── is_negative_zero.rs
│ │ │ │ │ │ │ ├── max_precision_for_sci_exponent.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ ├── next_higher.rs
│ │ │ │ │ │ │ ├── next_lower.rs
│ │ │ │ │ │ │ ├── precision.rs
│ │ │ │ │ │ │ └── to_ordered_representation.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ └── nice_float/
│ │ │ │ │ │ ├── cmp.rs
│ │ │ │ │ │ ├── cmp_abs.rs
│ │ │ │ │ │ ├── eq.rs
│ │ │ │ │ │ ├── eq_abs.rs
│ │ │ │ │ │ ├── from_str.rs
│ │ │ │ │ │ ├── hash.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ └── to_string.rs
│ │ │ │ │ ├── logic/
│ │ │ │ │ │ ├── bit_access/
│ │ │ │ │ │ │ ├── assign_bit.rs
│ │ │ │ │ │ │ ├── clear_bit.rs
│ │ │ │ │ │ │ ├── flip_bit.rs
│ │ │ │ │ │ │ ├── get_bit.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ └── set_bit.rs
│ │ │ │ │ │ ├── bit_block_access/
│ │ │ │ │ │ │ ├── assign_bits.rs
│ │ │ │ │ │ │ ├── get_bits.rs
│ │ │ │ │ │ │ └── mod.rs
│ │ │ │ │ │ ├── bit_convertible/
│ │ │ │ │ │ │ ├── from_bits.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ └── to_bits.rs
│ │ │ │ │ │ ├── bit_iterable.rs
│ │ │ │ │ │ ├── bit_scan/
│ │ │ │ │ │ │ ├── index_of_next_false_bit.rs
│ │ │ │ │ │ │ ├── index_of_next_true_bit.rs
│ │ │ │ │ │ │ └── mod.rs
│ │ │ │ │ │ ├── get_highest_bit.rs
│ │ │ │ │ │ ├── hamming_distance.rs
│ │ │ │ │ │ ├── low_mask.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── not_assign.rs
│ │ │ │ │ │ └── significant_bits.rs
│ │ │ │ │ └── mod.rs
│ │ │ │ ├── rational_sequences/
│ │ │ │ │ ├── access/
│ │ │ │ │ │ ├── get.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ └── mutate.rs
│ │ │ │ │ ├── basic/
│ │ │ │ │ │ ├── component_len.rs
│ │ │ │ │ │ ├── is_empty.rs
│ │ │ │ │ │ ├── is_finite.rs
│ │ │ │ │ │ ├── iter.rs
│ │ │ │ │ │ ├── len.rs
│ │ │ │ │ │ └── mod.rs
│ │ │ │ │ ├── comparison/
│ │ │ │ │ │ ├── cmp.rs
│ │ │ │ │ │ ├── eq.rs
│ │ │ │ │ │ ├── hash.rs
│ │ │ │ │ │ └── mod.rs
│ │ │ │ │ ├── conversion/
│ │ │ │ │ │ ├── clone.rs
│ │ │ │ │ │ ├── from_vec.rs
│ │ │ │ │ │ ├── from_vecs.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ └── to_vecs.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── to_string.rs
│ │ │ │ ├── rounding_modes/
│ │ │ │ │ ├── clone.rs
│ │ │ │ │ ├── eq.rs
│ │ │ │ │ ├── from_str.rs
│ │ │ │ │ ├── hash.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── neg.rs
│ │ │ │ │ └── to_string.rs
│ │ │ │ ├── slices/
│ │ │ │ │ ├── min_repeating_len.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── slice_leading_zeros.rs
│ │ │ │ │ ├── slice_move_left.rs
│ │ │ │ │ ├── slice_set_zero.rs
│ │ │ │ │ ├── slice_test_zero.rs
│ │ │ │ │ ├── slice_trailing_zeros.rs
│ │ │ │ │ └── split_into_chunks.rs
│ │ │ │ ├── strings/
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── string_is_subset.rs
│ │ │ │ │ ├── string_sort.rs
│ │ │ │ │ └── string_unique.rs
│ │ │ │ └── vecs/
│ │ │ │ ├── mod.rs
│ │ │ │ ├── vec_delete_left.rs
│ │ │ │ └── vec_pad_left.rs
│ │ │ └── generate/
│ │ │ ├── max_base.rs
│ │ │ ├── mod.rs
│ │ │ ├── rle.rs
│ │ │ └── tuning_manager.rs
│ │ ├── bools/
│ │ │ ├── constants.rs
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ ├── not_assign.rs
│ │ │ └── random.rs
│ │ ├── chars/
│ │ │ ├── constants.rs
│ │ │ ├── crement.rs
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ └── random.rs
│ │ ├── comparison/
│ │ │ ├── macros.rs
│ │ │ ├── mod.rs
│ │ │ └── traits.rs
│ │ ├── iterators/
│ │ │ ├── bit_distributor.rs
│ │ │ ├── comparison.rs
│ │ │ ├── iterator_cache.rs
│ │ │ └── mod.rs
│ │ ├── lib.rs
│ │ ├── macros/
│ │ │ └── mod.rs
│ │ ├── named/
│ │ │ └── mod.rs
│ │ ├── nevers/
│ │ │ └── mod.rs
│ │ ├── num/
│ │ │ ├── arithmetic/
│ │ │ │ ├── abs.rs
│ │ │ │ ├── abs_diff.rs
│ │ │ │ ├── add_mul.rs
│ │ │ │ ├── arithmetic_checked_shl.rs
│ │ │ │ ├── arithmetic_checked_shr.rs
│ │ │ │ ├── binomial_coefficient.rs
│ │ │ │ ├── ceiling.rs
│ │ │ │ ├── checked_abs.rs
│ │ │ │ ├── checked_add.rs
│ │ │ │ ├── checked_add_mul.rs
│ │ │ │ ├── checked_div.rs
│ │ │ │ ├── checked_mul.rs
│ │ │ │ ├── checked_neg.rs
│ │ │ │ ├── checked_next_power_of_2.rs
│ │ │ │ ├── checked_pow.rs
│ │ │ │ ├── checked_square.rs
│ │ │ │ ├── checked_sub.rs
│ │ │ │ ├── checked_sub_mul.rs
│ │ │ │ ├── coprime_with.rs
│ │ │ │ ├── div_exact.rs
│ │ │ │ ├── div_mod.rs
│ │ │ │ ├── div_round.rs
│ │ │ │ ├── divisible_by.rs
│ │ │ │ ├── divisible_by_power_of_2.rs
│ │ │ │ ├── eq_mod.rs
│ │ │ │ ├── eq_mod_power_of_2.rs
│ │ │ │ ├── extended_gcd.rs
│ │ │ │ ├── factorial.rs
│ │ │ │ ├── floor.rs
│ │ │ │ ├── gcd.rs
│ │ │ │ ├── is_power_of_2.rs
│ │ │ │ ├── kronecker_symbol.rs
│ │ │ │ ├── lcm.rs
│ │ │ │ ├── log_base.rs
│ │ │ │ ├── log_base_2.rs
│ │ │ │ ├── log_base_power_of_2.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── mod_add.rs
│ │ │ │ ├── mod_inverse.rs
│ │ │ │ ├── mod_is_reduced.rs
│ │ │ │ ├── mod_mul.rs
│ │ │ │ ├── mod_neg.rs
│ │ │ │ ├── mod_op.rs
│ │ │ │ ├── mod_pow.rs
│ │ │ │ ├── mod_power_of_2.rs
│ │ │ │ ├── mod_power_of_2_add.rs
│ │ │ │ ├── mod_power_of_2_inverse.rs
│ │ │ │ ├── mod_power_of_2_is_reduced.rs
│ │ │ │ ├── mod_power_of_2_mul.rs
│ │ │ │ ├── mod_power_of_2_neg.rs
│ │ │ │ ├── mod_power_of_2_pow.rs
│ │ │ │ ├── mod_power_of_2_shl.rs
│ │ │ │ ├── mod_power_of_2_shr.rs
│ │ │ │ ├── mod_power_of_2_square.rs
│ │ │ │ ├── mod_power_of_2_sub.rs
│ │ │ │ ├── mod_shl.rs
│ │ │ │ ├── mod_shr.rs
│ │ │ │ ├── mod_square.rs
│ │ │ │ ├── mod_sub.rs
│ │ │ │ ├── neg.rs
│ │ │ │ ├── next_power_of_2.rs
│ │ │ │ ├── overflowing_abs.rs
│ │ │ │ ├── overflowing_add.rs
│ │ │ │ ├── overflowing_add_mul.rs
│ │ │ │ ├── overflowing_div.rs
│ │ │ │ ├── overflowing_mul.rs
│ │ │ │ ├── overflowing_neg.rs
│ │ │ │ ├── overflowing_pow.rs
│ │ │ │ ├── overflowing_square.rs
│ │ │ │ ├── overflowing_sub.rs
│ │ │ │ ├── overflowing_sub_mul.rs
│ │ │ │ ├── parity.rs
│ │ │ │ ├── pow.rs
│ │ │ │ ├── power_of_2.rs
│ │ │ │ ├── primorial.rs
│ │ │ │ ├── reciprocal.rs
│ │ │ │ ├── root.rs
│ │ │ │ ├── rotate.rs
│ │ │ │ ├── round_to_multiple.rs
│ │ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ │ ├── saturating_abs.rs
│ │ │ │ ├── saturating_add.rs
│ │ │ │ ├── saturating_add_mul.rs
│ │ │ │ ├── saturating_mul.rs
│ │ │ │ ├── saturating_neg.rs
│ │ │ │ ├── saturating_pow.rs
│ │ │ │ ├── saturating_square.rs
│ │ │ │ ├── saturating_sub.rs
│ │ │ │ ├── saturating_sub_mul.rs
│ │ │ │ ├── shl_round.rs
│ │ │ │ ├── shr_round.rs
│ │ │ │ ├── sign.rs
│ │ │ │ ├── sqrt.rs
│ │ │ │ ├── square.rs
│ │ │ │ ├── sub_mul.rs
│ │ │ │ ├── traits.rs
│ │ │ │ ├── wrapping_abs.rs
│ │ │ │ ├── wrapping_add.rs
│ │ │ │ ├── wrapping_add_mul.rs
│ │ │ │ ├── wrapping_div.rs
│ │ │ │ ├── wrapping_mul.rs
│ │ │ │ ├── wrapping_neg.rs
│ │ │ │ ├── wrapping_pow.rs
│ │ │ │ ├── wrapping_square.rs
│ │ │ │ ├── wrapping_sub.rs
│ │ │ │ ├── wrapping_sub_mul.rs
│ │ │ │ ├── x_mul_y_to_zz.rs
│ │ │ │ ├── xx_add_yy_to_zz.rs
│ │ │ │ ├── xx_div_mod_y_to_qr.rs
│ │ │ │ ├── xx_sub_yy_to_zz.rs
│ │ │ │ ├── xxx_add_yyy_to_zzz.rs
│ │ │ │ ├── xxx_sub_yyy_to_zzz.rs
│ │ │ │ └── xxxx_add_yyyy_to_zzzz.rs
│ │ │ ├── basic/
│ │ │ │ ├── floats.rs
│ │ │ │ ├── integers.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── signeds.rs
│ │ │ │ ├── traits.rs
│ │ │ │ └── unsigneds.rs
│ │ │ ├── comparison/
│ │ │ │ ├── cmp_abs.rs
│ │ │ │ ├── eq_abs.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── traits.rs
│ │ │ ├── conversion/
│ │ │ │ ├── digits/
│ │ │ │ │ ├── general_digits.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── power_of_2_digit_iterable.rs
│ │ │ │ │ └── power_of_2_digits.rs
│ │ │ │ ├── from.rs
│ │ │ │ ├── half.rs
│ │ │ │ ├── is_integer.rs
│ │ │ │ ├── mantissa_and_exponent.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── slice.rs
│ │ │ │ ├── string/
│ │ │ │ │ ├── from_sci_string.rs
│ │ │ │ │ ├── from_string.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── options/
│ │ │ │ │ │ ├── exhaustive.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ └── random.rs
│ │ │ │ │ ├── to_sci.rs
│ │ │ │ │ └── to_string.rs
│ │ │ │ └── traits.rs
│ │ │ ├── exhaustive/
│ │ │ │ └── mod.rs
│ │ │ ├── factorization/
│ │ │ │ ├── factor.rs
│ │ │ │ ├── is_power.rs
│ │ │ │ ├── is_prime.rs
│ │ │ │ ├── is_square.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── prime_sieve.rs
│ │ │ │ ├── primes.rs
│ │ │ │ ├── primitive_root_prime.rs
│ │ │ │ └── traits.rs
│ │ │ ├── float/
│ │ │ │ └── mod.rs
│ │ │ ├── iterators/
│ │ │ │ └── mod.rs
│ │ │ ├── logic/
│ │ │ │ ├── bit_access.rs
│ │ │ │ ├── bit_block_access.rs
│ │ │ │ ├── bit_convertible.rs
│ │ │ │ ├── bit_iterable.rs
│ │ │ │ ├── bit_scan.rs
│ │ │ │ ├── count_ones.rs
│ │ │ │ ├── count_zeros.rs
│ │ │ │ ├── hamming_distance.rs
│ │ │ │ ├── leading_zeros.rs
│ │ │ │ ├── low_mask.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── not.rs
│ │ │ │ ├── significant_bits.rs
│ │ │ │ ├── trailing_zeros.rs
│ │ │ │ └── traits.rs
│ │ │ ├── macros.rs
│ │ │ ├── mod.rs
│ │ │ └── random/
│ │ │ ├── geometric.rs
│ │ │ ├── mod.rs
│ │ │ └── striped.rs
│ │ ├── options/
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ └── random.rs
│ │ ├── orderings/
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ └── random.rs
│ │ ├── platform.rs
│ │ ├── random/
│ │ │ └── mod.rs
│ │ ├── rational_sequences/
│ │ │ ├── access.rs
│ │ │ ├── cmp.rs
│ │ │ ├── conversion.rs
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ ├── random.rs
│ │ │ └── to_string.rs
│ │ ├── rounding_modes/
│ │ │ ├── exhaustive.rs
│ │ │ ├── from_str.rs
│ │ │ ├── mod.rs
│ │ │ ├── neg.rs
│ │ │ ├── random.rs
│ │ │ └── to_string.rs
│ │ ├── sets/
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ └── random.rs
│ │ ├── slices/
│ │ │ └── mod.rs
│ │ ├── strings/
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ └── random.rs
│ │ ├── test_util/
│ │ │ ├── bench/
│ │ │ │ ├── bucketers.rs
│ │ │ │ └── mod.rs
│ │ │ ├── common/
│ │ │ │ └── mod.rs
│ │ │ ├── extra_variadic/
│ │ │ │ └── mod.rs
│ │ │ ├── generators/
│ │ │ │ ├── common.rs
│ │ │ │ ├── exhaustive.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── random.rs
│ │ │ │ └── special_random.rs
│ │ │ ├── hash/
│ │ │ │ └── mod.rs
│ │ │ ├── mod.rs
│ │ │ ├── num/
│ │ │ │ ├── arithmetic/
│ │ │ │ │ ├── extended_gcd.rs
│ │ │ │ │ ├── factorial.rs
│ │ │ │ │ ├── kronecker_symbol.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── mod_inverse.rs
│ │ │ │ │ ├── mod_mul.rs
│ │ │ │ │ ├── mod_pow.rs
│ │ │ │ │ ├── mod_power_of_2_inverse.rs
│ │ │ │ │ └── primorial.rs
│ │ │ │ ├── conversion/
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── string/
│ │ │ │ │ ├── from_sci_string.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── to_string.rs
│ │ │ │ ├── exhaustive/
│ │ │ │ │ └── mod.rs
│ │ │ │ ├── factorization/
│ │ │ │ │ ├── factor.rs
│ │ │ │ │ ├── is_prime.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── prime_sieve.rs
│ │ │ │ │ └── primes.rs
│ │ │ │ ├── float/
│ │ │ │ │ └── mod.rs
│ │ │ │ ├── logic/
│ │ │ │ │ ├── bit_block_access.rs
│ │ │ │ │ ├── bit_convertible.rs
│ │ │ │ │ └── mod.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── random/
│ │ │ │ ├── geometric.rs
│ │ │ │ └── mod.rs
│ │ │ ├── rounding_modes/
│ │ │ │ └── mod.rs
│ │ │ ├── runner/
│ │ │ │ ├── cmd.rs
│ │ │ │ └── mod.rs
│ │ │ ├── sets/
│ │ │ │ ├── exhaustive/
│ │ │ │ │ └── mod.rs
│ │ │ │ └── mod.rs
│ │ │ ├── slices/
│ │ │ │ └── mod.rs
│ │ │ ├── stats/
│ │ │ │ ├── common_values_map.rs
│ │ │ │ ├── median.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── moments.rs
│ │ │ └── vecs/
│ │ │ ├── exhaustive/
│ │ │ │ └── mod.rs
│ │ │ ├── mod.rs
│ │ │ └── random/
│ │ │ └── mod.rs
│ │ ├── tuples/
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ └── random.rs
│ │ ├── unions/
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ └── random.rs
│ │ └── vecs/
│ │ ├── exhaustive.rs
│ │ ├── mod.rs
│ │ └── random.rs
│ └── tests/
│ ├── bools/
│ │ ├── constants.rs
│ │ ├── exhaustive.rs
│ │ ├── not_assign.rs
│ │ └── random/
│ │ ├── get_weighted_random_bool.rs
│ │ ├── random_bools.rs
│ │ └── weighted_random_bools.rs
│ ├── chars/
│ │ ├── char_type.rs
│ │ ├── constants.rs
│ │ ├── crement/
│ │ │ ├── char_to_contiguous_range.rs
│ │ │ ├── contiguous_range_to_char.rs
│ │ │ └── crement.rs
│ │ ├── exhaustive/
│ │ │ ├── ascii_chars_increasing.rs
│ │ │ ├── chars_increasing.rs
│ │ │ ├── exhaustive_ascii_chars.rs
│ │ │ └── exhaustive_chars.rs
│ │ ├── is_graphic.rs
│ │ └── random/
│ │ ├── graphic_weighted_random_ascii_chars.rs
│ │ ├── graphic_weighted_random_char_inclusive_range.rs
│ │ ├── graphic_weighted_random_char_range.rs
│ │ ├── graphic_weighted_random_chars.rs
│ │ ├── random_ascii_chars.rs
│ │ ├── random_char_inclusive_range.rs
│ │ ├── random_char_range.rs
│ │ └── random_chars.rs
│ ├── comparison/
│ │ └── macros.rs
│ ├── extra_variadic/
│ │ └── mod.rs
│ ├── iterators/
│ │ ├── bit_distributor/
│ │ │ ├── bit_map_as_slice.rs
│ │ │ ├── get_output.rs
│ │ │ ├── increment_counter.rs
│ │ │ ├── new.rs
│ │ │ └── set_max_bits.rs
│ │ ├── comparison/
│ │ │ ├── delta_directions.rs
│ │ │ ├── is_strictly_ascending.rs
│ │ │ ├── is_strictly_descending.rs
│ │ │ ├── is_strictly_zigzagging.rs
│ │ │ ├── is_weakly_ascending.rs
│ │ │ ├── is_weakly_descending.rs
│ │ │ └── is_weakly_zigzagging.rs
│ │ ├── count_is_at_least.rs
│ │ ├── count_is_at_most.rs
│ │ ├── first_and_last.rs
│ │ ├── is_constant.rs
│ │ ├── is_unique.rs
│ │ ├── iter_windows.rs
│ │ ├── iterator_cache.rs
│ │ ├── matching_intervals_in_iterator.rs
│ │ ├── nonzero_values.rs
│ │ ├── prefix_to_string.rs
│ │ ├── thue_morse_sequence.rs
│ │ ├── with_special_value.rs
│ │ └── with_special_values.rs
│ ├── lib.rs
│ ├── named/
│ │ └── mod.rs
│ ├── nevers/
│ │ └── nevers.rs
│ ├── num/
│ │ ├── arithmetic/
│ │ │ ├── abs.rs
│ │ │ ├── abs_diff.rs
│ │ │ ├── add_mul.rs
│ │ │ ├── arithmetic_checked_shl.rs
│ │ │ ├── arithmetic_checked_shr.rs
│ │ │ ├── binomial_coefficient.rs
│ │ │ ├── ceiling.rs
│ │ │ ├── checked_abs.rs
│ │ │ ├── checked_add_mul.rs
│ │ │ ├── checked_neg.rs
│ │ │ ├── checked_pow.rs
│ │ │ ├── checked_square.rs
│ │ │ ├── checked_sub_mul.rs
│ │ │ ├── coprime_with.rs
│ │ │ ├── div_exact.rs
│ │ │ ├── div_mod.rs
│ │ │ ├── div_round.rs
│ │ │ ├── divisible_by.rs
│ │ │ ├── divisible_by_power_of_2.rs
│ │ │ ├── eq_mod.rs
│ │ │ ├── eq_mod_power_of_2.rs
│ │ │ ├── extended_gcd.rs
│ │ │ ├── factorial.rs
│ │ │ ├── floor.rs
│ │ │ ├── gcd.rs
│ │ │ ├── is_power_of_2.rs
│ │ │ ├── kronecker_symbol.rs
│ │ │ ├── lcm.rs
│ │ │ ├── log_base.rs
│ │ │ ├── log_base_2.rs
│ │ │ ├── log_base_power_of_2.rs
│ │ │ ├── mod_add.rs
│ │ │ ├── mod_inverse.rs
│ │ │ ├── mod_is_reduced.rs
│ │ │ ├── mod_mul.rs
│ │ │ ├── mod_neg.rs
│ │ │ ├── mod_op.rs
│ │ │ ├── mod_pow.rs
│ │ │ ├── mod_power_of_2.rs
│ │ │ ├── mod_power_of_2_add.rs
│ │ │ ├── mod_power_of_2_inverse.rs
│ │ │ ├── mod_power_of_2_is_reduced.rs
│ │ │ ├── mod_power_of_2_mul.rs
│ │ │ ├── mod_power_of_2_neg.rs
│ │ │ ├── mod_power_of_2_pow.rs
│ │ │ ├── mod_power_of_2_shl.rs
│ │ │ ├── mod_power_of_2_shr.rs
│ │ │ ├── mod_power_of_2_square.rs
│ │ │ ├── mod_power_of_2_sub.rs
│ │ │ ├── mod_shl.rs
│ │ │ ├── mod_shr.rs
│ │ │ ├── mod_square.rs
│ │ │ ├── mod_sub.rs
│ │ │ ├── neg.rs
│ │ │ ├── next_power_of_2.rs
│ │ │ ├── overflowing_abs.rs
│ │ │ ├── overflowing_add.rs
│ │ │ ├── overflowing_add_mul.rs
│ │ │ ├── overflowing_div.rs
│ │ │ ├── overflowing_mul.rs
│ │ │ ├── overflowing_neg.rs
│ │ │ ├── overflowing_pow.rs
│ │ │ ├── overflowing_square.rs
│ │ │ ├── overflowing_sub.rs
│ │ │ ├── overflowing_sub_mul.rs
│ │ │ ├── parity.rs
│ │ │ ├── pow.rs
│ │ │ ├── power_of_2.rs
│ │ │ ├── primorial.rs
│ │ │ ├── reciprocal.rs
│ │ │ ├── root.rs
│ │ │ ├── rotate.rs
│ │ │ ├── round_to_multiple.rs
│ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ ├── saturating_abs.rs
│ │ │ ├── saturating_add.rs
│ │ │ ├── saturating_add_mul.rs
│ │ │ ├── saturating_mul.rs
│ │ │ ├── saturating_neg.rs
│ │ │ ├── saturating_pow.rs
│ │ │ ├── saturating_square.rs
│ │ │ ├── saturating_sub.rs
│ │ │ ├── saturating_sub_mul.rs
│ │ │ ├── shl_round.rs
│ │ │ ├── shr_round.rs
│ │ │ ├── sign.rs
│ │ │ ├── sqrt.rs
│ │ │ ├── square.rs
│ │ │ ├── sub_mul.rs
│ │ │ ├── wrapping_abs.rs
│ │ │ ├── wrapping_add.rs
│ │ │ ├── wrapping_add_mul.rs
│ │ │ ├── wrapping_div.rs
│ │ │ ├── wrapping_mul.rs
│ │ │ ├── wrapping_neg.rs
│ │ │ ├── wrapping_pow.rs
│ │ │ ├── wrapping_square.rs
│ │ │ ├── wrapping_sub.rs
│ │ │ ├── wrapping_sub_mul.rs
│ │ │ ├── x_mul_y_to_zz.rs
│ │ │ ├── xx_add_yy_to_zz.rs
│ │ │ ├── xx_div_mod_y_to_qr.rs
│ │ │ ├── xx_sub_yy_to_zz.rs
│ │ │ ├── xxx_add_yyy_to_zzz.rs
│ │ │ ├── xxx_sub_yyy_to_zzz.rs
│ │ │ └── xxxx_add_yyyy_to_zzzz.rs
│ │ ├── basic/
│ │ │ └── constants.rs
│ │ ├── comparison/
│ │ │ ├── cmp_abs.rs
│ │ │ └── eq_abs.rs
│ │ ├── conversion/
│ │ │ ├── digits/
│ │ │ │ ├── general_digits/
│ │ │ │ │ ├── from_digits.rs
│ │ │ │ │ └── to_digits.rs
│ │ │ │ └── power_of_2_digits/
│ │ │ │ ├── from_power_of_2_digits.rs
│ │ │ │ ├── power_of_2_digit_iterable.rs
│ │ │ │ └── to_power_of_2_digits.rs
│ │ │ ├── froms/
│ │ │ │ ├── convertible_from.rs
│ │ │ │ ├── from.rs
│ │ │ │ ├── overflowing_from.rs
│ │ │ │ ├── rounding_from.rs
│ │ │ │ ├── saturating_from.rs
│ │ │ │ ├── try_from_and_exact_from.rs
│ │ │ │ └── wrapping_from.rs
│ │ │ ├── half/
│ │ │ │ ├── join_halves.rs
│ │ │ │ ├── lower_half.rs
│ │ │ │ ├── split_in_half.rs
│ │ │ │ └── upper_half.rs
│ │ │ ├── is_integer.rs
│ │ │ ├── mantissa_and_exponent/
│ │ │ │ ├── integer_mantissa_and_exponent.rs
│ │ │ │ ├── raw_mantissa_and_exponent.rs
│ │ │ │ └── sci_mantissa_and_exponent.rs
│ │ │ ├── slice/
│ │ │ │ ├── from_other_type_slice.rs
│ │ │ │ ├── vec_from_other_type.rs
│ │ │ │ └── vec_from_other_type_slice.rs
│ │ │ └── string/
│ │ │ ├── from_sci_string.rs
│ │ │ ├── from_string.rs
│ │ │ ├── options/
│ │ │ │ ├── from_sci_string_options.rs
│ │ │ │ └── to_sci_options.rs
│ │ │ ├── to_sci.rs
│ │ │ └── to_string.rs
│ │ ├── exhaustive/
│ │ │ ├── exhaustive_finite_primitive_floats.rs
│ │ │ ├── exhaustive_natural_signeds.rs
│ │ │ ├── exhaustive_negative_finite_primitive_floats.rs
│ │ │ ├── exhaustive_negative_primitive_floats.rs
│ │ │ ├── exhaustive_negative_signeds.rs
│ │ │ ├── exhaustive_nonzero_finite_primitive_floats.rs
│ │ │ ├── exhaustive_nonzero_finite_primitive_floats_in_range.rs
│ │ │ ├── exhaustive_nonzero_primitive_floats.rs
│ │ │ ├── exhaustive_nonzero_signeds.rs
│ │ │ ├── exhaustive_positive_finite_primitive_floats.rs
│ │ │ ├── exhaustive_positive_finite_primitive_floats_in_range.rs
│ │ │ ├── exhaustive_positive_primitive_floats.rs
│ │ │ ├── exhaustive_positive_primitive_ints.rs
│ │ │ ├── exhaustive_primitive_float_inclusive_range.rs
│ │ │ ├── exhaustive_primitive_float_range.rs
│ │ │ ├── exhaustive_primitive_floats.rs
│ │ │ ├── exhaustive_primitive_floats_with_sci_exponent.rs
│ │ │ ├── exhaustive_primitive_floats_with_sci_exponent_and_precision.rs
│ │ │ ├── exhaustive_primitive_floats_with_sci_exponent_and_precision_in_range.rs
│ │ │ ├── exhaustive_primitive_floats_with_sci_exponent_in_range.rs
│ │ │ ├── exhaustive_signed_inclusive_range.rs
│ │ │ ├── exhaustive_signed_range.rs
│ │ │ ├── exhaustive_signeds.rs
│ │ │ ├── exhaustive_unsigneds.rs
│ │ │ ├── finite_primitive_floats_increasing.rs
│ │ │ ├── negative_finite_primitive_floats_increasing.rs
│ │ │ ├── negative_primitive_floats_increasing.rs
│ │ │ ├── nonzero_finite_primitive_floats_increasing.rs
│ │ │ ├── nonzero_primitive_floats_increasing.rs
│ │ │ ├── positive_finite_primitive_floats_increasing.rs
│ │ │ ├── positive_primitive_floats_increasing.rs
│ │ │ ├── primitive_float_increasing_inclusive_range.rs
│ │ │ ├── primitive_float_increasing_range.rs
│ │ │ ├── primitive_floats_increasing.rs
│ │ │ ├── primitive_int_increasing_inclusive_range.rs
│ │ │ └── primitive_int_increasing_range.rs
│ │ ├── factorization/
│ │ │ ├── factor.rs
│ │ │ ├── is_power.rs
│ │ │ ├── is_prime.rs
│ │ │ ├── is_square.rs
│ │ │ ├── prime_indicator_sequence.rs
│ │ │ ├── prime_indicator_sequence_less_than.rs
│ │ │ ├── prime_sieve.rs
│ │ │ ├── primes.rs
│ │ │ └── primitive_root_prime.rs
│ │ ├── float/
│ │ │ ├── basic/
│ │ │ │ ├── abs_negative_zero.rs
│ │ │ │ ├── from_ordered_representation.rs
│ │ │ │ ├── is_negative_zero.rs
│ │ │ │ ├── max_precision_for_sci_exponent.rs
│ │ │ │ ├── next_higher.rs
│ │ │ │ ├── next_lower.rs
│ │ │ │ ├── precision.rs
│ │ │ │ └── to_ordered_representation.rs
│ │ │ └── nice_float/
│ │ │ ├── cmp.rs
│ │ │ ├── cmp_abs.rs
│ │ │ ├── eq.rs
│ │ │ ├── eq_abs.rs
│ │ │ ├── from_str.rs
│ │ │ ├── hash.rs
│ │ │ └── to_string.rs
│ │ ├── iterators/
│ │ │ ├── bit_distributor_sequence.rs
│ │ │ ├── iterator_to_bit_chunks.rs
│ │ │ └── ruler_sequence.rs
│ │ ├── logic/
│ │ │ ├── bit_access/
│ │ │ │ ├── assign_bit.rs
│ │ │ │ ├── clear_bit.rs
│ │ │ │ ├── flip_bit.rs
│ │ │ │ ├── get_bit.rs
│ │ │ │ └── set_bit.rs
│ │ │ ├── bit_block_access/
│ │ │ │ ├── assign_bits.rs
│ │ │ │ └── get_bits.rs
│ │ │ ├── bit_convertible/
│ │ │ │ ├── from_bits.rs
│ │ │ │ └── to_bits.rs
│ │ │ ├── bit_iterable.rs
│ │ │ ├── bit_scan/
│ │ │ │ ├── index_of_next_false_bit.rs
│ │ │ │ └── index_of_next_true_bit.rs
│ │ │ ├── get_highest_bit.rs
│ │ │ ├── hamming_distance.rs
│ │ │ ├── low_mask.rs
│ │ │ ├── not_assign.rs
│ │ │ └── significant_bits.rs
│ │ └── random/
│ │ ├── geometric/
│ │ │ ├── geometric_random_natural_signeds.rs
│ │ │ ├── geometric_random_negative_signeds.rs
│ │ │ ├── geometric_random_nonzero_signeds.rs
│ │ │ ├── geometric_random_positive_signeds.rs
│ │ │ ├── geometric_random_positive_unsigneds.rs
│ │ │ ├── geometric_random_signed_inclusive_range.rs
│ │ │ ├── geometric_random_signed_range.rs
│ │ │ ├── geometric_random_signeds.rs
│ │ │ ├── geometric_random_unsigned_inclusive_range.rs
│ │ │ ├── geometric_random_unsigned_range.rs
│ │ │ ├── geometric_random_unsigneds.rs
│ │ │ ├── get_geometric_random_signed_from_inclusive_range.rs
│ │ │ └── mean.rs
│ │ ├── random_finite_primitive_floats.rs
│ │ ├── random_highest_bit_set_unsigneds.rs
│ │ ├── random_natural_signeds.rs
│ │ ├── random_negative_finite_primitive_floats.rs
│ │ ├── random_negative_primitive_floats.rs
│ │ ├── random_negative_signeds.rs
│ │ ├── random_nonzero_finite_primitive_floats.rs
│ │ ├── random_nonzero_primitive_floats.rs
│ │ ├── random_nonzero_signeds.rs
│ │ ├── random_positive_finite_primitive_floats.rs
│ │ ├── random_positive_primitive_floats.rs
│ │ ├── random_positive_signeds.rs
│ │ ├── random_positive_unsigneds.rs
│ │ ├── random_primitive_float_inclusive_range.rs
│ │ ├── random_primitive_float_range.rs
│ │ ├── random_primitive_floats.rs
│ │ ├── random_primitive_ints.rs
│ │ ├── random_signed_bit_chunks.rs
│ │ ├── random_signed_inclusive_range.rs
│ │ ├── random_signed_range.rs
│ │ ├── random_unsigned_bit_chunks.rs
│ │ ├── random_unsigned_inclusive_range.rs
│ │ ├── random_unsigned_range.rs
│ │ ├── random_unsigneds_less_than.rs
│ │ ├── special_random_finite_primitive_floats.rs
│ │ ├── special_random_negative_finite_primitive_floats.rs
│ │ ├── special_random_negative_primitive_floats.rs
│ │ ├── special_random_nonzero_finite_primitive_floats.rs
│ │ ├── special_random_nonzero_primitive_floats.rs
│ │ ├── special_random_positive_finite_primitive_floats.rs
│ │ ├── special_random_positive_primitive_floats.rs
│ │ ├── special_random_primitive_float_inclusive_range.rs
│ │ ├── special_random_primitive_float_range.rs
│ │ ├── special_random_primitive_floats.rs
│ │ ├── striped/
│ │ │ ├── get_striped_bool_vec.rs
│ │ │ ├── get_striped_unsigned_vec.rs
│ │ │ ├── striped_bit_source.rs
│ │ │ ├── striped_random_bool_vecs.rs
│ │ │ ├── striped_random_bool_vecs_from_length_iterator.rs
│ │ │ ├── striped_random_bool_vecs_length_inclusive_range.rs
│ │ │ ├── striped_random_bool_vecs_length_range.rs
│ │ │ ├── striped_random_bool_vecs_min_length.rs
│ │ │ ├── striped_random_fixed_length_bool_vecs.rs
│ │ │ ├── striped_random_fixed_length_unsigned_vecs.rs
│ │ │ ├── striped_random_natural_signeds.rs
│ │ │ ├── striped_random_negative_signeds.rs
│ │ │ ├── striped_random_nonzero_signeds.rs
│ │ │ ├── striped_random_positive_signeds.rs
│ │ │ ├── striped_random_positive_unsigneds.rs
│ │ │ ├── striped_random_signed_inclusive_range.rs
│ │ │ ├── striped_random_signed_range.rs
│ │ │ ├── striped_random_signeds.rs
│ │ │ ├── striped_random_unsigned_bit_chunks.rs
│ │ │ ├── striped_random_unsigned_inclusive_range.rs
│ │ │ ├── striped_random_unsigned_range.rs
│ │ │ ├── striped_random_unsigned_vecs.rs
│ │ │ ├── striped_random_unsigned_vecs_from_length_iterator.rs
│ │ │ ├── striped_random_unsigned_vecs_length_inclusive_range.rs
│ │ │ ├── striped_random_unsigned_vecs_length_range.rs
│ │ │ ├── striped_random_unsigned_vecs_min_length.rs
│ │ │ └── striped_random_unsigneds.rs
│ │ └── variable_range_generator/
│ │ ├── next_bit_chunk.rs
│ │ ├── next_bool.rs
│ │ ├── next_in_inclusive_range.rs
│ │ ├── next_in_range.rs
│ │ └── next_less_than.rs
│ ├── options/
│ │ ├── exhaustive/
│ │ │ ├── exhaustive_options.rs
│ │ │ └── exhaustive_somes.rs
│ │ ├── option_from_str.rs
│ │ └── random/
│ │ ├── random_options.rs
│ │ └── random_somes.rs
│ ├── orderings/
│ │ ├── exhaustive.rs
│ │ ├── ordering_from_str.rs
│ │ └── random.rs
│ ├── random/
│ │ ├── fork.rs
│ │ ├── from_bytes.rs
│ │ ├── get_rng.rs
│ │ └── next.rs
│ ├── rational_sequences/
│ │ ├── access/
│ │ │ ├── get.rs
│ │ │ └── mutate.rs
│ │ ├── basic/
│ │ │ ├── component_len.rs
│ │ │ ├── is_empty.rs
│ │ │ ├── is_finite.rs
│ │ │ ├── iter.rs
│ │ │ └── len.rs
│ │ ├── comparison/
│ │ │ ├── cmp.rs
│ │ │ ├── eq.rs
│ │ │ └── hash.rs
│ │ ├── conversion/
│ │ │ ├── clone.rs
│ │ │ ├── from_vec.rs
│ │ │ ├── from_vecs.rs
│ │ │ └── to_vecs.rs
│ │ ├── exhaustive.rs
│ │ ├── random.rs
│ │ └── to_string.rs
│ ├── rounding_modes/
│ │ ├── clone.rs
│ │ ├── cmp.rs
│ │ ├── eq.rs
│ │ ├── exhaustive.rs
│ │ ├── from_str.rs
│ │ ├── hash.rs
│ │ ├── neg.rs
│ │ ├── random.rs
│ │ ├── size.rs
│ │ └── to_string.rs
│ ├── sets/
│ │ ├── exhaustive/
│ │ │ ├── exhaustive_b_tree_sets.rs
│ │ │ ├── exhaustive_b_tree_sets_fixed_length.rs
│ │ │ ├── exhaustive_b_tree_sets_length_inclusive_range.rs
│ │ │ ├── exhaustive_b_tree_sets_length_range.rs
│ │ │ ├── exhaustive_b_tree_sets_min_length.rs
│ │ │ ├── exhaustive_hash_sets.rs
│ │ │ ├── exhaustive_hash_sets_fixed_length.rs
│ │ │ ├── exhaustive_hash_sets_length_inclusive_range.rs
│ │ │ ├── exhaustive_hash_sets_length_range.rs
│ │ │ ├── exhaustive_hash_sets_min_length.rs
│ │ │ ├── lex_b_tree_sets.rs
│ │ │ ├── lex_b_tree_sets_fixed_length.rs
│ │ │ ├── lex_b_tree_sets_length_inclusive_range.rs
│ │ │ ├── lex_b_tree_sets_length_range.rs
│ │ │ ├── lex_b_tree_sets_min_length.rs
│ │ │ ├── lex_hash_sets.rs
│ │ │ ├── lex_hash_sets_fixed_length.rs
│ │ │ ├── lex_hash_sets_length_inclusive_range.rs
│ │ │ ├── lex_hash_sets_length_range.rs
│ │ │ ├── lex_hash_sets_min_length.rs
│ │ │ ├── shortlex_b_tree_sets.rs
│ │ │ ├── shortlex_b_tree_sets_length_inclusive_range.rs
│ │ │ ├── shortlex_b_tree_sets_length_range.rs
│ │ │ ├── shortlex_b_tree_sets_min_length.rs
│ │ │ ├── shortlex_hash_sets.rs
│ │ │ ├── shortlex_hash_sets_length_inclusive_range.rs
│ │ │ ├── shortlex_hash_sets_length_range.rs
│ │ │ └── shortlex_hash_sets_min_length.rs
│ │ └── random/
│ │ ├── random_b_tree_sets.rs
│ │ ├── random_b_tree_sets_fixed_length.rs
│ │ ├── random_b_tree_sets_from_length_iterator.rs
│ │ ├── random_b_tree_sets_length_inclusive_range.rs
│ │ ├── random_b_tree_sets_length_range.rs
│ │ ├── random_b_tree_sets_min_length.rs
│ │ ├── random_hash_sets.rs
│ │ ├── random_hash_sets_fixed_length.rs
│ │ ├── random_hash_sets_from_length_iterator.rs
│ │ ├── random_hash_sets_length_inclusive_range.rs
│ │ ├── random_hash_sets_length_range.rs
│ │ └── random_hash_sets_min_length.rs
│ ├── slices/
│ │ ├── exhaustive_slice_permutations.rs
│ │ ├── min_repeating_len.rs
│ │ ├── random_slice_permutations.rs
│ │ ├── random_values_from_slice.rs
│ │ ├── slice_leading_zeros.rs
│ │ ├── slice_move_left.rs
│ │ ├── slice_set_zero.rs
│ │ ├── slice_test_zero.rs
│ │ ├── slice_trailing_zeros.rs
│ │ └── split_into_chunks.rs
│ ├── strings/
│ │ ├── exhaustive/
│ │ │ ├── exhaustive_fixed_length_strings.rs
│ │ │ ├── exhaustive_fixed_length_strings_using_chars.rs
│ │ │ ├── exhaustive_strings.rs
│ │ │ ├── exhaustive_strings_using_chars.rs
│ │ │ ├── lex_fixed_length_strings.rs
│ │ │ ├── lex_fixed_length_strings_using_chars.rs
│ │ │ ├── shortlex_strings.rs
│ │ │ └── shortlex_strings_using_chars.rs
│ │ ├── random/
│ │ │ ├── random_fixed_length_strings.rs
│ │ │ ├── random_fixed_length_strings_using_chars.rs
│ │ │ ├── random_strings.rs
│ │ │ └── random_strings_using_chars.rs
│ │ ├── string_is_subset.rs
│ │ ├── string_sort.rs
│ │ ├── string_unique.rs
│ │ ├── strings_from_char_vecs.rs
│ │ ├── to_binary_string.rs
│ │ ├── to_debug_string.rs
│ │ ├── to_lower_hex_string.rs
│ │ ├── to_octal_string.rs
│ │ └── to_upper_hex_string.rs
│ ├── tuples/
│ │ ├── exhaustive/
│ │ │ ├── exhaustive_custom_tuples.rs
│ │ │ ├── exhaustive_dependent_pairs.rs
│ │ │ ├── exhaustive_ordered_unique_tuples.rs
│ │ │ ├── exhaustive_tuples_1_input.rs
│ │ │ ├── exhaustive_tuples_custom_output.rs
│ │ │ ├── exhaustive_tuples_from_single.rs
│ │ │ ├── exhaustive_unique_tuples.rs
│ │ │ ├── exhaustive_units.rs
│ │ │ ├── lex_custom_tuples.rs
│ │ │ ├── lex_dependent_pairs.rs
│ │ │ ├── lex_ordered_unique_tuples.rs
│ │ │ ├── lex_tuples.rs
│ │ │ ├── lex_tuples_from_single.rs
│ │ │ └── lex_unique_tuples.rs
│ │ ├── random/
│ │ │ ├── random_custom_tuples.rs
│ │ │ ├── random_ordered_unique_tuples.rs
│ │ │ ├── random_tuples.rs
│ │ │ ├── random_tuples_from_single.rs
│ │ │ ├── random_unique_tuples.rs
│ │ │ └── random_units.rs
│ │ └── singletons.rs
│ ├── unions/
│ │ ├── clone.rs
│ │ ├── debug.rs
│ │ ├── display.rs
│ │ ├── eq.rs
│ │ ├── exhaustive/
│ │ │ ├── exhaustive_unions.rs
│ │ │ └── lex_unions.rs
│ │ ├── from_str.rs
│ │ ├── ord.rs
│ │ ├── random/
│ │ │ └── random_unions.rs
│ │ └── unwrap.rs
│ └── vecs/
│ ├── exhaustive/
│ │ ├── exhaustive_combined_k_compositions.rs
│ │ ├── exhaustive_ordered_unique_vecs.rs
│ │ ├── exhaustive_ordered_unique_vecs_fixed_length.rs
│ │ ├── exhaustive_ordered_unique_vecs_length_inclusive_range.rs
│ │ ├── exhaustive_ordered_unique_vecs_length_range.rs
│ │ ├── exhaustive_ordered_unique_vecs_min_length.rs
│ │ ├── exhaustive_unique_vecs.rs
│ │ ├── exhaustive_unique_vecs_fixed_length.rs
│ │ ├── exhaustive_unique_vecs_length_inclusive_range.rs
│ │ ├── exhaustive_unique_vecs_length_range.rs
│ │ ├── exhaustive_unique_vecs_min_length.rs
│ │ ├── exhaustive_vecs.rs
│ │ ├── exhaustive_vecs_fixed_length_from_single.rs
│ │ ├── exhaustive_vecs_fixed_length_m_inputs.rs
│ │ ├── exhaustive_vecs_from_length_iterator.rs
│ │ ├── exhaustive_vecs_length_inclusive_range.rs
│ │ ├── exhaustive_vecs_length_n.rs
│ │ ├── exhaustive_vecs_length_range.rs
│ │ ├── exhaustive_vecs_min_length.rs
│ │ ├── lex_k_compositions.rs
│ │ ├── lex_ordered_unique_vecs.rs
│ │ ├── lex_ordered_unique_vecs_fixed_length.rs
│ │ ├── lex_ordered_unique_vecs_length_inclusive_range.rs
│ │ ├── lex_ordered_unique_vecs_length_range.rs
│ │ ├── lex_ordered_unique_vecs_min_length.rs
│ │ ├── lex_unique_vecs.rs
│ │ ├── lex_unique_vecs_fixed_length.rs
│ │ ├── lex_unique_vecs_length_inclusive_range.rs
│ │ ├── lex_unique_vecs_length_range.rs
│ │ ├── lex_unique_vecs_min_length.rs
│ │ ├── lex_vecs_fixed_length_from_single.rs
│ │ ├── lex_vecs_fixed_length_m_inputs.rs
│ │ ├── lex_vecs_length_n.rs
│ │ ├── next_bit_pattern.rs
│ │ ├── shortlex_ordered_unique_vecs.rs
│ │ ├── shortlex_ordered_unique_vecs_length_inclusive_range.rs
│ │ ├── shortlex_ordered_unique_vecs_length_range.rs
│ │ ├── shortlex_ordered_unique_vecs_min_length.rs
│ │ ├── shortlex_unique_vecs.rs
│ │ ├── shortlex_unique_vecs_length_inclusive_range.rs
│ │ ├── shortlex_unique_vecs_length_range.rs
│ │ ├── shortlex_unique_vecs_min_length.rs
│ │ ├── shortlex_vecs.rs
│ │ ├── shortlex_vecs_from_length_iterator.rs
│ │ ├── shortlex_vecs_length_inclusive_range.rs
│ │ ├── shortlex_vecs_length_range.rs
│ │ └── shortlex_vecs_min_length.rs
│ ├── exhaustive_vec_permutations.rs
│ ├── random/
│ │ ├── random_ordered_unique_vecs.rs
│ │ ├── random_ordered_unique_vecs_fixed_length.rs
│ │ ├── random_ordered_unique_vecs_from_length_iterator.rs
│ │ ├── random_ordered_unique_vecs_length_inclusive_range.rs
│ │ ├── random_ordered_unique_vecs_length_range.rs
│ │ ├── random_ordered_unique_vecs_min_length.rs
│ │ ├── random_unique_vecs.rs
│ │ ├── random_unique_vecs_fixed_length.rs
│ │ ├── random_unique_vecs_from_length_iterator.rs
│ │ ├── random_unique_vecs_length_inclusive_range.rs
│ │ ├── random_unique_vecs_length_range.rs
│ │ ├── random_unique_vecs_min_length.rs
│ │ ├── random_vecs.rs
│ │ ├── random_vecs_fixed_length.rs
│ │ ├── random_vecs_fixed_length_from_single.rs
│ │ ├── random_vecs_fixed_length_m_inputs.rs
│ │ ├── random_vecs_from_length_iterator.rs
│ │ ├── random_vecs_length_inclusive_range.rs
│ │ ├── random_vecs_length_range.rs
│ │ └── random_vecs_min_length.rs
│ ├── random_values_from_vec.rs
│ ├── random_vec_permutations.rs
│ ├── vec_delete_left.rs
│ ├── vec_from_str.rs
│ └── vec_pad_left.rs
├── malachite-bigint/
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── bigint.rs
│ ├── biguint.rs
│ ├── error.rs
│ ├── iter.rs
│ ├── lib.rs
│ ├── macros.rs
│ └── num_bigint_conversion.rs
├── malachite-criterion-bench/
│ ├── Cargo.toml
│ └── benches/
│ ├── bin.rs
│ ├── natural_div.rs
│ └── natural_mul.rs
├── malachite-float/
│ ├── Cargo.toml
│ ├── README.md
│ ├── katex-header.html
│ ├── rustfmt.toml
│ ├── src/
│ │ ├── arithmetic/
│ │ │ ├── abs.rs
│ │ │ ├── add.rs
│ │ │ ├── agm.rs
│ │ │ ├── div.rs
│ │ │ ├── is_power_of_2.rs
│ │ │ ├── ln.rs
│ │ │ ├── mod.rs
│ │ │ ├── mul.rs
│ │ │ ├── neg.rs
│ │ │ ├── power_of_2.rs
│ │ │ ├── reciprocal.rs
│ │ │ ├── reciprocal_sqrt.rs
│ │ │ ├── shl.rs
│ │ │ ├── shl_round.rs
│ │ │ ├── shr.rs
│ │ │ ├── shr_round.rs
│ │ │ ├── sign.rs
│ │ │ ├── sqrt.rs
│ │ │ ├── square.rs
│ │ │ └── sub.rs
│ │ ├── basic/
│ │ │ ├── classification.rs
│ │ │ ├── complexity.rs
│ │ │ ├── constants.rs
│ │ │ ├── extended.rs
│ │ │ ├── get_and_set.rs
│ │ │ ├── mod.rs
│ │ │ └── ulp.rs
│ │ ├── bin.rs
│ │ ├── bin_util/
│ │ │ └── demo_and_bench/
│ │ │ ├── arithmetic/
│ │ │ │ ├── abs.rs
│ │ │ │ ├── add.rs
│ │ │ │ ├── agm.rs
│ │ │ │ ├── div.rs
│ │ │ │ ├── is_power_of_2.rs
│ │ │ │ ├── ln.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── mul.rs
│ │ │ │ ├── neg.rs
│ │ │ │ ├── power_of_2.rs
│ │ │ │ ├── reciprocal.rs
│ │ │ │ ├── reciprocal_sqrt.rs
│ │ │ │ ├── shl.rs
│ │ │ │ ├── shl_round.rs
│ │ │ │ ├── shr.rs
│ │ │ │ ├── shr_round.rs
│ │ │ │ ├── sign.rs
│ │ │ │ ├── sqrt.rs
│ │ │ │ ├── square.rs
│ │ │ │ └── sub.rs
│ │ │ ├── basic/
│ │ │ │ ├── classification.rs
│ │ │ │ ├── complexity.rs
│ │ │ │ ├── constants.rs
│ │ │ │ ├── get_and_set.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── overflow_and_underflow.rs
│ │ │ │ └── ulp.rs
│ │ │ ├── comparison/
│ │ │ │ ├── cmp.rs
│ │ │ │ ├── cmp_abs.rs
│ │ │ │ ├── eq.rs
│ │ │ │ ├── eq_abs.rs
│ │ │ │ ├── eq_abs_integer.rs
│ │ │ │ ├── eq_abs_natural.rs
│ │ │ │ ├── eq_abs_primitive_float.rs
│ │ │ │ ├── eq_abs_primitive_int.rs
│ │ │ │ ├── eq_abs_rational.rs
│ │ │ │ ├── hash.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── partial_cmp_abs_integer.rs
│ │ │ │ ├── partial_cmp_abs_natural.rs
│ │ │ │ ├── partial_cmp_abs_primitive_float.rs
│ │ │ │ ├── partial_cmp_abs_primitive_int.rs
│ │ │ │ ├── partial_cmp_abs_rational.rs
│ │ │ │ ├── partial_cmp_integer.rs
│ │ │ │ ├── partial_cmp_natural.rs
│ │ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ │ ├── partial_cmp_rational.rs
│ │ │ │ ├── partial_eq_integer.rs
│ │ │ │ ├── partial_eq_natural.rs
│ │ │ │ ├── partial_eq_primitive_float.rs
│ │ │ │ ├── partial_eq_primitive_int.rs
│ │ │ │ └── partial_eq_rational.rs
│ │ │ ├── constants/
│ │ │ │ ├── gauss_constant.rs
│ │ │ │ ├── lemniscate_constant.rs
│ │ │ │ ├── ln_2.rs
│ │ │ │ ├── log_2_e.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── one_over_pi.rs
│ │ │ │ ├── one_over_sqrt_pi.rs
│ │ │ │ ├── one_over_sqrt_tau.rs
│ │ │ │ ├── phi.rs
│ │ │ │ ├── pi.rs
│ │ │ │ ├── pi_over_2.rs
│ │ │ │ ├── pi_over_3.rs
│ │ │ │ ├── pi_over_4.rs
│ │ │ │ ├── pi_over_6.rs
│ │ │ │ ├── pi_over_8.rs
│ │ │ │ ├── prime_constant.rs
│ │ │ │ ├── prouhet_thue_morse_constant.rs
│ │ │ │ ├── sqrt_2.rs
│ │ │ │ ├── sqrt_2_over_2.rs
│ │ │ │ ├── sqrt_3.rs
│ │ │ │ ├── sqrt_3_over_3.rs
│ │ │ │ ├── sqrt_pi.rs
│ │ │ │ ├── tau.rs
│ │ │ │ ├── two_over_pi.rs
│ │ │ │ └── two_over_sqrt_pi.rs
│ │ │ ├── conversion/
│ │ │ │ ├── clone.rs
│ │ │ │ ├── from_integer.rs
│ │ │ │ ├── from_natural.rs
│ │ │ │ ├── from_primitive_float.rs
│ │ │ │ ├── from_primitive_int.rs
│ │ │ │ ├── from_rational.rs
│ │ │ │ ├── integer_from_float.rs
│ │ │ │ ├── integer_mantissa_and_exponent.rs
│ │ │ │ ├── is_integer.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── natural_from_float.rs
│ │ │ │ ├── primitive_float_from_float.rs
│ │ │ │ ├── primitive_int_from_float.rs
│ │ │ │ ├── rational_from_float.rs
│ │ │ │ ├── raw_mantissa_and_exponent.rs
│ │ │ │ ├── sci_mantissa_and_exponent.rs
│ │ │ │ └── string/
│ │ │ │ ├── mod.rs
│ │ │ │ └── to_string.rs
│ │ │ └── mod.rs
│ │ ├── comparison/
│ │ │ ├── cmp.rs
│ │ │ ├── cmp_abs.rs
│ │ │ ├── eq.rs
│ │ │ ├── eq_abs.rs
│ │ │ ├── eq_abs_integer.rs
│ │ │ ├── eq_abs_natural.rs
│ │ │ ├── eq_abs_primitive_float.rs
│ │ │ ├── eq_abs_primitive_int.rs
│ │ │ ├── eq_abs_rational.rs
│ │ │ ├── hash.rs
│ │ │ ├── mod.rs
│ │ │ ├── partial_cmp_abs_integer.rs
│ │ │ ├── partial_cmp_abs_natural.rs
│ │ │ ├── partial_cmp_abs_primitive_float.rs
│ │ │ ├── partial_cmp_abs_primitive_int.rs
│ │ │ ├── partial_cmp_abs_rational.rs
│ │ │ ├── partial_cmp_integer.rs
│ │ │ ├── partial_cmp_natural.rs
│ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ ├── partial_cmp_rational.rs
│ │ │ ├── partial_eq_integer.rs
│ │ │ ├── partial_eq_natural.rs
│ │ │ ├── partial_eq_primitive_float.rs
│ │ │ ├── partial_eq_primitive_int.rs
│ │ │ └── partial_eq_rational.rs
│ │ ├── constants/
│ │ │ ├── gauss_constant.rs
│ │ │ ├── lemniscate_constant.rs
│ │ │ ├── ln_2.rs
│ │ │ ├── log_2_e.rs
│ │ │ ├── mod.rs
│ │ │ ├── one_over_pi.rs
│ │ │ ├── one_over_sqrt_pi.rs
│ │ │ ├── one_over_sqrt_tau.rs
│ │ │ ├── phi.rs
│ │ │ ├── pi.rs
│ │ │ ├── pi_over_2.rs
│ │ │ ├── pi_over_3.rs
│ │ │ ├── pi_over_4.rs
│ │ │ ├── pi_over_6.rs
│ │ │ ├── pi_over_8.rs
│ │ │ ├── prime_constant.rs
│ │ │ ├── prouhet_thue_morse_constant.rs
│ │ │ ├── sqrt_2.rs
│ │ │ ├── sqrt_2_over_2.rs
│ │ │ ├── sqrt_3.rs
│ │ │ ├── sqrt_3_over_3.rs
│ │ │ ├── sqrt_pi.rs
│ │ │ ├── tau.rs
│ │ │ ├── two_over_pi.rs
│ │ │ └── two_over_sqrt_pi.rs
│ │ ├── conversion/
│ │ │ ├── from_bits.rs
│ │ │ ├── from_integer.rs
│ │ │ ├── from_natural.rs
│ │ │ ├── from_primitive_float.rs
│ │ │ ├── from_primitive_int.rs
│ │ │ ├── from_rational.rs
│ │ │ ├── integer_from_float.rs
│ │ │ ├── is_integer.rs
│ │ │ ├── mantissa_and_exponent.rs
│ │ │ ├── mod.rs
│ │ │ ├── natural_from_float.rs
│ │ │ ├── primitive_float_from_float.rs
│ │ │ ├── primitive_int_from_float.rs
│ │ │ ├── rational_from_float.rs
│ │ │ └── string/
│ │ │ ├── from_string.rs
│ │ │ ├── mod.rs
│ │ │ └── to_string.rs
│ │ ├── exhaustive/
│ │ │ └── mod.rs
│ │ ├── lib.rs
│ │ ├── random/
│ │ │ └── mod.rs
│ │ └── test_util/
│ │ ├── arithmetic/
│ │ │ ├── add.rs
│ │ │ ├── agm.rs
│ │ │ ├── div.rs
│ │ │ ├── ln.rs
│ │ │ ├── mod.rs
│ │ │ ├── mul.rs
│ │ │ ├── power_of_2.rs
│ │ │ ├── reciprocal.rs
│ │ │ ├── reciprocal_sqrt.rs
│ │ │ ├── shl.rs
│ │ │ ├── shl_round.rs
│ │ │ ├── shr.rs
│ │ │ ├── shr_round.rs
│ │ │ ├── sqrt.rs
│ │ │ ├── square.rs
│ │ │ └── sub.rs
│ │ ├── bench/
│ │ │ ├── bucketers.rs
│ │ │ └── mod.rs
│ │ ├── common/
│ │ │ └── mod.rs
│ │ ├── comparison/
│ │ │ ├── mod.rs
│ │ │ └── partial_cmp_rational.rs
│ │ ├── constants/
│ │ │ ├── lemniscate_constant.rs
│ │ │ ├── ln_2.rs
│ │ │ ├── log_2_e.rs
│ │ │ ├── mod.rs
│ │ │ ├── one_over_pi.rs
│ │ │ ├── one_over_sqrt_pi.rs
│ │ │ ├── one_over_sqrt_tau.rs
│ │ │ ├── pi.rs
│ │ │ ├── pi_over_3.rs
│ │ │ ├── prime_constant.rs
│ │ │ ├── prouhet_thue_morse_constant.rs
│ │ │ ├── sqrt_2.rs
│ │ │ ├── sqrt_2_over_2.rs
│ │ │ ├── sqrt_3.rs
│ │ │ ├── sqrt_3_over_3.rs
│ │ │ └── sqrt_pi.rs
│ │ ├── conversion/
│ │ │ ├── from_primitive_float.rs
│ │ │ └── mod.rs
│ │ ├── exhaustive/
│ │ │ └── mod.rs
│ │ ├── extra_variadic/
│ │ │ └── mod.rs
│ │ ├── generators/
│ │ │ ├── common.rs
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ ├── random.rs
│ │ │ └── special_random.rs
│ │ ├── mod.rs
│ │ └── random/
│ │ └── mod.rs
│ └── tests/
│ ├── arithmetic/
│ │ ├── abs.rs
│ │ ├── add.rs
│ │ ├── agm.rs
│ │ ├── div.rs
│ │ ├── is_power_of_2.rs
│ │ ├── ln.rs
│ │ ├── mul.rs
│ │ ├── neg.rs
│ │ ├── power_of_2.rs
│ │ ├── reciprocal.rs
│ │ ├── reciprocal_sqrt.rs
│ │ ├── shl.rs
│ │ ├── shl_round.rs
│ │ ├── shr.rs
│ │ ├── shr_round.rs
│ │ ├── sign.rs
│ │ ├── sqrt.rs
│ │ ├── square.rs
│ │ └── sub.rs
│ ├── basic/
│ │ ├── classification.rs
│ │ ├── complexity.rs
│ │ ├── constants.rs
│ │ ├── get_and_set.rs
│ │ ├── named.rs
│ │ ├── overflow_and_underflow.rs
│ │ ├── size.rs
│ │ └── ulp.rs
│ ├── comparison/
│ │ ├── cmp.rs
│ │ ├── cmp_abs.rs
│ │ ├── eq.rs
│ │ ├── eq_abs.rs
│ │ ├── eq_abs_integer.rs
│ │ ├── eq_abs_natural.rs
│ │ ├── eq_abs_primitive_float.rs
│ │ ├── eq_abs_primitive_int.rs
│ │ ├── eq_abs_rational.rs
│ │ ├── hash.rs
│ │ ├── partial_cmp_abs_integer.rs
│ │ ├── partial_cmp_abs_natural.rs
│ │ ├── partial_cmp_abs_primitive_float.rs
│ │ ├── partial_cmp_abs_primitive_int.rs
│ │ ├── partial_cmp_abs_rational.rs
│ │ ├── partial_cmp_integer.rs
│ │ ├── partial_cmp_natural.rs
│ │ ├── partial_cmp_primitive_float.rs
│ │ ├── partial_cmp_primitive_int.rs
│ │ ├── partial_cmp_rational.rs
│ │ ├── partial_eq_integer.rs
│ │ ├── partial_eq_natural.rs
│ │ ├── partial_eq_primitive_float.rs
│ │ ├── partial_eq_primitive_int.rs
│ │ └── partial_eq_rational.rs
│ ├── constants/
│ │ ├── gauss_constant.rs
│ │ ├── lemniscate_constant.rs
│ │ ├── ln_2.rs
│ │ ├── log_2_e.rs
│ │ ├── one_over_pi.rs
│ │ ├── one_over_sqrt_pi.rs
│ │ ├── one_over_sqrt_tau.rs
│ │ ├── phi.rs
│ │ ├── pi.rs
│ │ ├── pi_over_2.rs
│ │ ├── pi_over_3.rs
│ │ ├── pi_over_4.rs
│ │ ├── pi_over_6.rs
│ │ ├── pi_over_8.rs
│ │ ├── prime_constant.rs
│ │ ├── prouhet_thue_morse_constant.rs
│ │ ├── sqrt_2.rs
│ │ ├── sqrt_2_over_2.rs
│ │ ├── sqrt_3.rs
│ │ ├── sqrt_3_over_3.rs
│ │ ├── sqrt_pi.rs
│ │ ├── tau.rs
│ │ ├── two_over_pi.rs
│ │ └── two_over_sqrt_pi.rs
│ ├── conversion/
│ │ ├── clone.rs
│ │ ├── from_integer.rs
│ │ ├── from_natural.rs
│ │ ├── from_primitive_float.rs
│ │ ├── from_primitive_int.rs
│ │ ├── from_rational.rs
│ │ ├── integer_from_float.rs
│ │ ├── is_integer.rs
│ │ ├── mantissa_and_exponent.rs
│ │ ├── natural_from_float.rs
│ │ ├── primitive_float_from_float.rs
│ │ ├── primitive_int_from_float.rs
│ │ └── rational_from_float.rs
│ ├── exhaustive/
│ │ ├── exhaustive_finite_floats.rs
│ │ ├── exhaustive_floats.rs
│ │ ├── exhaustive_floats_with_precision.rs
│ │ ├── exhaustive_negative_finite_floats.rs
│ │ ├── exhaustive_non_negative_finite_floats.rs
│ │ ├── exhaustive_non_positive_finite_floats.rs
│ │ ├── exhaustive_nonzero_finite_floats.rs
│ │ ├── exhaustive_positive_finite_floats.rs
│ │ ├── exhaustive_positive_floats_with_precision.rs
│ │ ├── exhaustive_positive_floats_with_sci_exponent.rs
│ │ └── exhaustive_positive_floats_with_sci_exponent_and_precision.rs
│ ├── lib.rs
│ └── random/
│ ├── random_finite_floats.rs
│ ├── random_floats.rs
│ ├── random_negative_finite_floats.rs
│ ├── random_non_negative_finite_floats.rs
│ ├── random_non_positive_finite_floats.rs
│ ├── random_nonzero_finite_floats.rs
│ ├── random_positive_finite_floats.rs
│ ├── random_positive_floats_with_precision.rs
│ ├── striped_random_finite_floats.rs
│ ├── striped_random_floats.rs
│ ├── striped_random_negative_finite_floats.rs
│ ├── striped_random_non_negative_finite_floats.rs
│ ├── striped_random_non_positive_finite_floats.rs
│ ├── striped_random_nonzero_finite_floats.rs
│ ├── striped_random_positive_finite_floats.rs
│ └── striped_random_positive_floats_with_precision.rs
├── malachite-nz/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── extra-tests.py
│ ├── images/
│ │ └── natural-mem-layout.asy
│ ├── katex-header.html
│ ├── rustfmt.toml
│ ├── src/
│ │ ├── bin.rs
│ │ ├── bin_util/
│ │ │ ├── demo_and_bench/
│ │ │ │ ├── integer/
│ │ │ │ │ ├── arithmetic/
│ │ │ │ │ │ ├── abs.rs
│ │ │ │ │ │ ├── abs_diff.rs
│ │ │ │ │ │ ├── add.rs
│ │ │ │ │ │ ├── add_mul.rs
│ │ │ │ │ │ ├── binomial_coefficient.rs
│ │ │ │ │ │ ├── div.rs
│ │ │ │ │ │ ├── div_exact.rs
│ │ │ │ │ │ ├── div_mod.rs
│ │ │ │ │ │ ├── div_round.rs
│ │ │ │ │ │ ├── divisible_by.rs
│ │ │ │ │ │ ├── divisible_by_power_of_2.rs
│ │ │ │ │ │ ├── eq_mod.rs
│ │ │ │ │ │ ├── eq_mod_power_of_2.rs
│ │ │ │ │ │ ├── extended_gcd.rs
│ │ │ │ │ │ ├── kronecker_symbol.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── mod_op.rs
│ │ │ │ │ │ ├── mod_power_of_2.rs
│ │ │ │ │ │ ├── mul.rs
│ │ │ │ │ │ ├── neg.rs
│ │ │ │ │ │ ├── parity.rs
│ │ │ │ │ │ ├── pow.rs
│ │ │ │ │ │ ├── power_of_2.rs
│ │ │ │ │ │ ├── root.rs
│ │ │ │ │ │ ├── round_to_multiple.rs
│ │ │ │ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ │ │ │ ├── shl.rs
│ │ │ │ │ │ ├── shl_round.rs
│ │ │ │ │ │ ├── shr.rs
│ │ │ │ │ │ ├── shr_round.rs
│ │ │ │ │ │ ├── sign.rs
│ │ │ │ │ │ ├── sqrt.rs
│ │ │ │ │ │ ├── square.rs
│ │ │ │ │ │ ├── sub.rs
│ │ │ │ │ │ └── sub_mul.rs
│ │ │ │ │ ├── basic/
│ │ │ │ │ │ ├── from_sign_and_abs.rs
│ │ │ │ │ │ └── mod.rs
│ │ │ │ │ ├── comparison/
│ │ │ │ │ │ ├── cmp.rs
│ │ │ │ │ │ ├── cmp_abs.rs
│ │ │ │ │ │ ├── eq.rs
│ │ │ │ │ │ ├── eq_abs.rs
│ │ │ │ │ │ ├── eq_abs_natural.rs
│ │ │ │ │ │ ├── eq_abs_primitive_float.rs
│ │ │ │ │ │ ├── eq_abs_primitive_int.rs
│ │ │ │ │ │ ├── hash.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── partial_cmp_abs_natural.rs
│ │ │ │ │ │ ├── partial_cmp_abs_primitive_float.rs
│ │ │ │ │ │ ├── partial_cmp_abs_primitive_int.rs
│ │ │ │ │ │ ├── partial_cmp_natural.rs
│ │ │ │ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ │ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ │ │ │ ├── partial_eq_natural.rs
│ │ │ │ │ │ ├── partial_eq_primitive_float.rs
│ │ │ │ │ │ └── partial_eq_primitive_int.rs
│ │ │ │ │ ├── conversion/
│ │ │ │ │ │ ├── clone.rs
│ │ │ │ │ │ ├── floating_point_from_integer.rs
│ │ │ │ │ │ ├── from_bool.rs
│ │ │ │ │ │ ├── from_floating_point.rs
│ │ │ │ │ │ ├── from_natural.rs
│ │ │ │ │ │ ├── from_primitive_int.rs
│ │ │ │ │ │ ├── from_twos_complement_limbs.rs
│ │ │ │ │ │ ├── is_integer.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── natural_from_integer.rs
│ │ │ │ │ │ ├── primitive_int_from_integer.rs
│ │ │ │ │ │ ├── serde.rs
│ │ │ │ │ │ ├── string/
│ │ │ │ │ │ │ ├── from_sci_string.rs
│ │ │ │ │ │ │ ├── from_string.rs
│ │ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ │ ├── to_sci.rs
│ │ │ │ │ │ │ └── to_string.rs
│ │ │ │ │ │ └── to_twos_complement_limbs.rs
│ │ │ │ │ ├── logic/
│ │ │ │ │ │ ├── and.rs
│ │ │ │ │ │ ├── assign_bit.rs
│ │ │ │ │ │ ├── assign_bits.rs
│ │ │ │ │ │ ├── bits.rs
│ │ │ │ │ │ ├── checked_count_ones.rs
│ │ │ │ │ │ ├── checked_count_zeros.rs
│ │ │ │ │ │ ├── checked_hamming_distance.rs
│ │ │ │ │ │ ├── clear_bit.rs
│ │ │ │ │ │ ├── flip_bit.rs
│ │ │ │ │ │ ├── from_bits.rs
│ │ │ │ │ │ ├── get_bit.rs
│ │ │ │ │ │ ├── get_bits.rs
│ │ │ │ │ │ ├── index_of_next_false_bit.rs
│ │ │ │ │ │ ├── index_of_next_true_bit.rs
│ │ │ │ │ │ ├── low_mask.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── not.rs
│ │ │ │ │ │ ├── or.rs
│ │ │ │ │ │ ├── set_bit.rs
│ │ │ │ │ │ ├── significant_bits.rs
│ │ │ │ │ │ ├── to_bits.rs
│ │ │ │ │ │ ├── trailing_zeros.rs
│ │ │ │ │ │ └── xor.rs
│ │ │ │ │ └── mod.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── natural/
│ │ │ │ ├── arithmetic/
│ │ │ │ │ ├── abs_diff.rs
│ │ │ │ │ ├── add.rs
│ │ │ │ │ ├── add_mul.rs
│ │ │ │ │ ├── binomial_coefficient.rs
│ │ │ │ │ ├── checked_sub.rs
│ │ │ │ │ ├── checked_sub_mul.rs
│ │ │ │ │ ├── coprime_with.rs
│ │ │ │ │ ├── div.rs
│ │ │ │ │ ├── div_exact.rs
│ │ │ │ │ ├── div_mod.rs
│ │ │ │ │ ├── div_round.rs
│ │ │ │ │ ├── divisible_by.rs
│ │ │ │ │ ├── divisible_by_power_of_2.rs
│ │ │ │ │ ├── eq_mod.rs
│ │ │ │ │ ├── eq_mod_power_of_2.rs
│ │ │ │ │ ├── extended_gcd.rs
│ │ │ │ │ ├── factorial.rs
│ │ │ │ │ ├── gcd.rs
│ │ │ │ │ ├── is_power_of_2.rs
│ │ │ │ │ ├── kronecker_symbol.rs
│ │ │ │ │ ├── lcm.rs
│ │ │ │ │ ├── log_base.rs
│ │ │ │ │ ├── log_base_2.rs
│ │ │ │ │ ├── log_base_power_of_2.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── mod_add.rs
│ │ │ │ │ ├── mod_inverse.rs
│ │ │ │ │ ├── mod_is_reduced.rs
│ │ │ │ │ ├── mod_mul.rs
│ │ │ │ │ ├── mod_neg.rs
│ │ │ │ │ ├── mod_op.rs
│ │ │ │ │ ├── mod_pow.rs
│ │ │ │ │ ├── mod_power_of_2.rs
│ │ │ │ │ ├── mod_power_of_2_add.rs
│ │ │ │ │ ├── mod_power_of_2_inverse.rs
│ │ │ │ │ ├── mod_power_of_2_is_reduced.rs
│ │ │ │ │ ├── mod_power_of_2_mul.rs
│ │ │ │ │ ├── mod_power_of_2_neg.rs
│ │ │ │ │ ├── mod_power_of_2_pow.rs
│ │ │ │ │ ├── mod_power_of_2_shl.rs
│ │ │ │ │ ├── mod_power_of_2_shr.rs
│ │ │ │ │ ├── mod_power_of_2_square.rs
│ │ │ │ │ ├── mod_power_of_2_sub.rs
│ │ │ │ │ ├── mod_shl.rs
│ │ │ │ │ ├── mod_shr.rs
│ │ │ │ │ ├── mod_square.rs
│ │ │ │ │ ├── mod_sub.rs
│ │ │ │ │ ├── mul.rs
│ │ │ │ │ ├── neg.rs
│ │ │ │ │ ├── next_power_of_2.rs
│ │ │ │ │ ├── parity.rs
│ │ │ │ │ ├── pow.rs
│ │ │ │ │ ├── power_of_2.rs
│ │ │ │ │ ├── primorial.rs
│ │ │ │ │ ├── root.rs
│ │ │ │ │ ├── round_to_multiple.rs
│ │ │ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ │ │ ├── saturating_sub.rs
│ │ │ │ │ ├── saturating_sub_mul.rs
│ │ │ │ │ ├── shl.rs
│ │ │ │ │ ├── shl_round.rs
│ │ │ │ │ ├── shr.rs
│ │ │ │ │ ├── shr_round.rs
│ │ │ │ │ ├── sign.rs
│ │ │ │ │ ├── sqrt.rs
│ │ │ │ │ ├── square.rs
│ │ │ │ │ ├── sub.rs
│ │ │ │ │ └── sub_mul.rs
│ │ │ │ ├── comparison/
│ │ │ │ │ ├── cmp.rs
│ │ │ │ │ ├── eq.rs
│ │ │ │ │ ├── eq_abs_primitive_float.rs
│ │ │ │ │ ├── eq_abs_primitive_int.rs
│ │ │ │ │ ├── hash.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── partial_cmp_abs_primitive_float.rs
│ │ │ │ │ ├── partial_cmp_abs_primitive_int.rs
│ │ │ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ │ │ ├── partial_eq_primitive_float.rs
│ │ │ │ │ └── partial_eq_primitive_int.rs
│ │ │ │ ├── conversion/
│ │ │ │ │ ├── clone.rs
│ │ │ │ │ ├── digits/
│ │ │ │ │ │ ├── from_digits.rs
│ │ │ │ │ │ ├── from_power_of_2_digits.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── power_of_2_digits.rs
│ │ │ │ │ │ ├── to_digits.rs
│ │ │ │ │ │ └── to_power_of_2_digits.rs
│ │ │ │ │ ├── floating_point_from_natural.rs
│ │ │ │ │ ├── from_bool.rs
│ │ │ │ │ ├── from_floating_point.rs
│ │ │ │ │ ├── from_limbs.rs
│ │ │ │ │ ├── from_primitive_int.rs
│ │ │ │ │ ├── integer_mantissa_and_exponent.rs
│ │ │ │ │ ├── is_integer.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── primitive_int_from_natural.rs
│ │ │ │ │ ├── sci_mantissa_and_exponent.rs
│ │ │ │ │ ├── serde.rs
│ │ │ │ │ ├── string/
│ │ │ │ │ │ ├── from_sci_string.rs
│ │ │ │ │ │ ├── from_string.rs
│ │ │ │ │ │ ├── mod.rs
│ │ │ │ │ │ ├── to_sci.rs
│ │ │ │ │ │ └── to_string.rs
│ │ │ │ │ └── to_limbs.rs
│ │ │ │ ├── factorization/
│ │ │ │ │ ├── is_power.rs
│ │ │ │ │ ├── is_square.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── primes.rs
│ │ │ │ ├── logic/
│ │ │ │ │ ├── and.rs
│ │ │ │ │ ├── assign_bit.rs
│ │ │ │ │ ├── assign_bits.rs
│ │ │ │ │ ├── bits.rs
│ │ │ │ │ ├── clear_bit.rs
│ │ │ │ │ ├── count_ones.rs
│ │ │ │ │ ├── flip_bit.rs
│ │ │ │ │ ├── from_bits.rs
│ │ │ │ │ ├── get_bit.rs
│ │ │ │ │ ├── get_bits.rs
│ │ │ │ │ ├── hamming_distance.rs
│ │ │ │ │ ├── index_of_next_false_bit.rs
│ │ │ │ │ ├── index_of_next_true_bit.rs
│ │ │ │ │ ├── low_mask.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── not.rs
│ │ │ │ │ ├── or.rs
│ │ │ │ │ ├── set_bit.rs
│ │ │ │ │ ├── significant_bits.rs
│ │ │ │ │ ├── to_bits.rs
│ │ │ │ │ ├── trailing_zeros.rs
│ │ │ │ │ └── xor.rs
│ │ │ │ └── mod.rs
│ │ │ └── generate/
│ │ │ ├── digits_data.rs
│ │ │ ├── factorial_data.rs
│ │ │ └── mod.rs
│ │ ├── integer/
│ │ │ ├── arithmetic/
│ │ │ │ ├── abs.rs
│ │ │ │ ├── abs_diff.rs
│ │ │ │ ├── add.rs
│ │ │ │ ├── add_mul.rs
│ │ │ │ ├── binomial_coefficient.rs
│ │ │ │ ├── div.rs
│ │ │ │ ├── div_exact.rs
│ │ │ │ ├── div_mod.rs
│ │ │ │ ├── div_round.rs
│ │ │ │ ├── divisible_by.rs
│ │ │ │ ├── divisible_by_power_of_2.rs
│ │ │ │ ├── eq_mod.rs
│ │ │ │ ├── eq_mod_power_of_2.rs
│ │ │ │ ├── extended_gcd.rs
│ │ │ │ ├── kronecker_symbol.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── mod_op.rs
│ │ │ │ ├── mod_power_of_2.rs
│ │ │ │ ├── mul.rs
│ │ │ │ ├── neg.rs
│ │ │ │ ├── parity.rs
│ │ │ │ ├── pow.rs
│ │ │ │ ├── power_of_2.rs
│ │ │ │ ├── root.rs
│ │ │ │ ├── round_to_multiple.rs
│ │ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ │ ├── shl.rs
│ │ │ │ ├── shl_round.rs
│ │ │ │ ├── shr.rs
│ │ │ │ ├── shr_round.rs
│ │ │ │ ├── sign.rs
│ │ │ │ ├── sqrt.rs
│ │ │ │ ├── square.rs
│ │ │ │ ├── sub.rs
│ │ │ │ └── sub_mul.rs
│ │ │ ├── comparison/
│ │ │ │ ├── cmp.rs
│ │ │ │ ├── cmp_abs.rs
│ │ │ │ ├── cmp_abs_natural.rs
│ │ │ │ ├── cmp_abs_primitive_float.rs
│ │ │ │ ├── cmp_abs_primitive_int.rs
│ │ │ │ ├── eq_abs.rs
│ │ │ │ ├── eq_abs_natural.rs
│ │ │ │ ├── eq_abs_primitive_float.rs
│ │ │ │ ├── eq_abs_primitive_int.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── partial_cmp_natural.rs
│ │ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ │ ├── partial_eq_natural.rs
│ │ │ │ ├── partial_eq_primitive_float.rs
│ │ │ │ └── partial_eq_primitive_int.rs
│ │ │ ├── conversion/
│ │ │ │ ├── from_bool.rs
│ │ │ │ ├── from_natural.rs
│ │ │ │ ├── from_primitive_float.rs
│ │ │ │ ├── from_primitive_int.rs
│ │ │ │ ├── from_twos_complement_limbs.rs
│ │ │ │ ├── is_integer.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── natural_from_integer.rs
│ │ │ │ ├── primitive_float_from_integer.rs
│ │ │ │ ├── primitive_int_from_integer.rs
│ │ │ │ ├── pyo3.rs
│ │ │ │ ├── serde.rs
│ │ │ │ ├── string/
│ │ │ │ │ ├── from_sci_string.rs
│ │ │ │ │ ├── from_string.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── to_sci.rs
│ │ │ │ │ └── to_string.rs
│ │ │ │ └── to_twos_complement_limbs.rs
│ │ │ ├── exhaustive/
│ │ │ │ └── mod.rs
│ │ │ ├── logic/
│ │ │ │ ├── and.rs
│ │ │ │ ├── bit_access.rs
│ │ │ │ ├── bit_block_access.rs
│ │ │ │ ├── bit_convertible.rs
│ │ │ │ ├── bit_iterable.rs
│ │ │ │ ├── bit_scan.rs
│ │ │ │ ├── checked_count_ones.rs
│ │ │ │ ├── checked_count_zeros.rs
│ │ │ │ ├── checked_hamming_distance.rs
│ │ │ │ ├── low_mask.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── not.rs
│ │ │ │ ├── or.rs
│ │ │ │ ├── significant_bits.rs
│ │ │ │ ├── trailing_zeros.rs
│ │ │ │ └── xor.rs
│ │ │ ├── mod.rs
│ │ │ └── random/
│ │ │ └── mod.rs
│ │ ├── lib.rs
│ │ ├── natural/
│ │ │ ├── arithmetic/
│ │ │ │ ├── abs_diff.rs
│ │ │ │ ├── add.rs
│ │ │ │ ├── add_mul.rs
│ │ │ │ ├── binomial_coefficient.rs
│ │ │ │ ├── checked_sub.rs
│ │ │ │ ├── checked_sub_mul.rs
│ │ │ │ ├── coprime_with.rs
│ │ │ │ ├── div.rs
│ │ │ │ ├── div_exact.rs
│ │ │ │ ├── div_mod.rs
│ │ │ │ ├── div_round.rs
│ │ │ │ ├── divisible_by.rs
│ │ │ │ ├── divisible_by_power_of_2.rs
│ │ │ │ ├── eq_mod.rs
│ │ │ │ ├── eq_mod_power_of_2.rs
│ │ │ │ ├── factorial.rs
│ │ │ │ ├── float_add.rs
│ │ │ │ ├── float_div.rs
│ │ │ │ ├── float_extras.rs
│ │ │ │ ├── float_mul.rs
│ │ │ │ ├── float_reciprocal.rs
│ │ │ │ ├── float_reciprocal_sqrt.rs
│ │ │ │ ├── float_sqrt.rs
│ │ │ │ ├── float_square.rs
│ │ │ │ ├── float_sub.rs
│ │ │ │ ├── gcd/
│ │ │ │ │ ├── extended_gcd.rs
│ │ │ │ │ ├── half_gcd.rs
│ │ │ │ │ ├── matrix_2_2.rs
│ │ │ │ │ └── mod.rs
│ │ │ │ ├── is_power_of_2.rs
│ │ │ │ ├── kronecker_symbol.rs
│ │ │ │ ├── lcm.rs
│ │ │ │ ├── log_base.rs
│ │ │ │ ├── log_base_2.rs
│ │ │ │ ├── log_base_power_of_2.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── mod_add.rs
│ │ │ │ ├── mod_inverse.rs
│ │ │ │ ├── mod_is_reduced.rs
│ │ │ │ ├── mod_mul.rs
│ │ │ │ ├── mod_neg.rs
│ │ │ │ ├── mod_op.rs
│ │ │ │ ├── mod_pow.rs
│ │ │ │ ├── mod_power_of_2.rs
│ │ │ │ ├── mod_power_of_2_add.rs
│ │ │ │ ├── mod_power_of_2_inverse.rs
│ │ │ │ ├── mod_power_of_2_is_reduced.rs
│ │ │ │ ├── mod_power_of_2_mul.rs
│ │ │ │ ├── mod_power_of_2_neg.rs
│ │ │ │ ├── mod_power_of_2_pow.rs
│ │ │ │ ├── mod_power_of_2_shl.rs
│ │ │ │ ├── mod_power_of_2_shr.rs
│ │ │ │ ├── mod_power_of_2_square.rs
│ │ │ │ ├── mod_power_of_2_sub.rs
│ │ │ │ ├── mod_shl.rs
│ │ │ │ ├── mod_shr.rs
│ │ │ │ ├── mod_square.rs
│ │ │ │ ├── mod_sub.rs
│ │ │ │ ├── mul/
│ │ │ │ │ ├── context.rs
│ │ │ │ │ ├── fft.rs
│ │ │ │ │ ├── limb.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── mul_low.rs
│ │ │ │ │ ├── mul_mod.rs
│ │ │ │ │ ├── poly_eval.rs
│ │ │ │ │ ├── poly_interpolate.rs
│ │ │ │ │ ├── product_of_limbs.rs
│ │ │ │ │ └── toom.rs
│ │ │ │ ├── neg.rs
│ │ │ │ ├── next_power_of_2.rs
│ │ │ │ ├── parity.rs
│ │ │ │ ├── pow.rs
│ │ │ │ ├── power_of_2.rs
│ │ │ │ ├── primorial.rs
│ │ │ │ ├── root.rs
│ │ │ │ ├── round_to_multiple.rs
│ │ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ │ ├── saturating_sub.rs
│ │ │ │ ├── saturating_sub_mul.rs
│ │ │ │ ├── shl.rs
│ │ │ │ ├── shl_round.rs
│ │ │ │ ├── shr.rs
│ │ │ │ ├── shr_round.rs
│ │ │ │ ├── sign.rs
│ │ │ │ ├── sqrt.rs
│ │ │ │ ├── square.rs
│ │ │ │ ├── sub.rs
│ │ │ │ └── sub_mul.rs
│ │ │ ├── comparison/
│ │ │ │ ├── cmp.rs
│ │ │ │ ├── eq_abs_primitive_float.rs
│ │ │ │ ├── eq_abs_primitive_int.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── partial_cmp_abs_primitive_float.rs
│ │ │ │ ├── partial_cmp_abs_primitive_int.rs
│ │ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ │ ├── partial_eq_primitive_float.rs
│ │ │ │ └── partial_eq_primitive_int.rs
│ │ │ ├── conversion/
│ │ │ │ ├── digits/
│ │ │ │ │ ├── general_digits.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── power_of_2_digit_iterable.rs
│ │ │ │ │ └── power_of_2_digits.rs
│ │ │ │ ├── from_bool.rs
│ │ │ │ ├── from_limbs.rs
│ │ │ │ ├── from_primitive_float.rs
│ │ │ │ ├── from_primitive_int.rs
│ │ │ │ ├── is_integer.rs
│ │ │ │ ├── limb_count.rs
│ │ │ │ ├── mantissa_and_exponent.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── primitive_float_from_natural.rs
│ │ │ │ ├── primitive_int_from_natural.rs
│ │ │ │ ├── pyo3.rs
│ │ │ │ ├── serde.rs
│ │ │ │ ├── string/
│ │ │ │ │ ├── from_sci_string.rs
│ │ │ │ │ ├── from_string.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── to_sci.rs
│ │ │ │ │ └── to_string.rs
│ │ │ │ └── to_limbs.rs
│ │ │ ├── exhaustive/
│ │ │ │ └── mod.rs
│ │ │ ├── factorization/
│ │ │ │ ├── is_power.rs
│ │ │ │ ├── is_square.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── primes.rs
│ │ │ │ └── remove_power.rs
│ │ │ ├── logic/
│ │ │ │ ├── and.rs
│ │ │ │ ├── bit_access.rs
│ │ │ │ ├── bit_block_access.rs
│ │ │ │ ├── bit_convertible.rs
│ │ │ │ ├── bit_iterable.rs
│ │ │ │ ├── bit_scan.rs
│ │ │ │ ├── count_ones.rs
│ │ │ │ ├── hamming_distance.rs
│ │ │ │ ├── low_mask.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── not.rs
│ │ │ │ ├── or.rs
│ │ │ │ ├── significant_bits.rs
│ │ │ │ ├── trailing_zeros.rs
│ │ │ │ └── xor.rs
│ │ │ ├── mod.rs
│ │ │ └── random/
│ │ │ └── mod.rs
│ │ ├── platform_32.rs
│ │ ├── platform_64.rs
│ │ └── test_util/
│ │ ├── bench/
│ │ │ ├── bucketers.rs
│ │ │ └── mod.rs
│ │ ├── common/
│ │ │ └── mod.rs
│ │ ├── extra_variadic/
│ │ │ └── mod.rs
│ │ ├── generators/
│ │ │ ├── common.rs
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ ├── random.rs
│ │ │ └── special_random.rs
│ │ ├── integer/
│ │ │ ├── arithmetic/
│ │ │ │ ├── add.rs
│ │ │ │ ├── divisible_by.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── mul.rs
│ │ │ │ └── sign.rs
│ │ │ ├── comparison/
│ │ │ │ ├── mod.rs
│ │ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ │ └── partial_eq_primitive_int.rs
│ │ │ ├── conversion/
│ │ │ │ ├── mod.rs
│ │ │ │ └── to_twos_complement_limbs.rs
│ │ │ ├── logic/
│ │ │ │ ├── and.rs
│ │ │ │ ├── checked_count_ones.rs
│ │ │ │ ├── checked_count_zeros.rs
│ │ │ │ ├── checked_hamming_distance.rs
│ │ │ │ ├── from_bits.rs
│ │ │ │ ├── index_of_next_false_bit.rs
│ │ │ │ ├── index_of_next_true_bit.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── or.rs
│ │ │ │ ├── to_bits.rs
│ │ │ │ ├── trailing_zeros.rs
│ │ │ │ └── xor.rs
│ │ │ ├── mod.rs
│ │ │ └── random/
│ │ │ └── mod.rs
│ │ ├── mod.rs
│ │ └── natural/
│ │ ├── arithmetic/
│ │ │ ├── add.rs
│ │ │ ├── binomial_coefficient.rs
│ │ │ ├── checked_sub.rs
│ │ │ ├── div.rs
│ │ │ ├── div_exact.rs
│ │ │ ├── div_mod.rs
│ │ │ ├── divisible_by.rs
│ │ │ ├── eq_mod.rs
│ │ │ ├── extended_gcd.rs
│ │ │ ├── factorial.rs
│ │ │ ├── gcd.rs
│ │ │ ├── kronecker_symbol.rs
│ │ │ ├── log_base.rs
│ │ │ ├── log_base_power_of_2.rs
│ │ │ ├── mod.rs
│ │ │ ├── mod_inverse.rs
│ │ │ ├── mod_mul.rs
│ │ │ ├── mod_op.rs
│ │ │ ├── mod_pow.rs
│ │ │ ├── mod_power_of_2_pow.rs
│ │ │ ├── mod_power_of_2_square.rs
│ │ │ ├── mul.rs
│ │ │ ├── neg.rs
│ │ │ ├── pow.rs
│ │ │ ├── primorial.rs
│ │ │ ├── root.rs
│ │ │ ├── sqrt.rs
│ │ │ ├── square.rs
│ │ │ └── sub.rs
│ │ ├── comparison/
│ │ │ ├── cmp.rs
│ │ │ ├── mod.rs
│ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ └── partial_eq_primitive_int.rs
│ │ ├── conversion/
│ │ │ ├── mod.rs
│ │ │ └── string/
│ │ │ ├── from_string.rs
│ │ │ ├── mod.rs
│ │ │ └── to_string.rs
│ │ ├── logic/
│ │ │ ├── and.rs
│ │ │ ├── count_ones.rs
│ │ │ ├── from_bits.rs
│ │ │ ├── get_bit.rs
│ │ │ ├── hamming_distance.rs
│ │ │ ├── index_of_next_false_bit.rs
│ │ │ ├── index_of_next_true_bit.rs
│ │ │ ├── mod.rs
│ │ │ ├── or.rs
│ │ │ ├── set_bit.rs
│ │ │ ├── to_bits.rs
│ │ │ ├── trailing_zeros.rs
│ │ │ └── xor.rs
│ │ ├── mod.rs
│ │ └── random/
│ │ └── mod.rs
│ └── tests/
│ ├── integer/
│ │ ├── arithmetic/
│ │ │ ├── abs.rs
│ │ │ ├── abs_diff.rs
│ │ │ ├── add.rs
│ │ │ ├── add_mul.rs
│ │ │ ├── binomial_coefficient.rs
│ │ │ ├── div.rs
│ │ │ ├── div_exact.rs
│ │ │ ├── div_mod.rs
│ │ │ ├── div_round.rs
│ │ │ ├── divisible_by.rs
│ │ │ ├── divisible_by_power_of_2.rs
│ │ │ ├── eq_mod.rs
│ │ │ ├── eq_mod_power_of_2.rs
│ │ │ ├── extended_gcd.rs
│ │ │ ├── kronecker_symbol.rs
│ │ │ ├── mod_op.rs
│ │ │ ├── mod_power_of_2.rs
│ │ │ ├── mul.rs
│ │ │ ├── neg.rs
│ │ │ ├── parity.rs
│ │ │ ├── pow.rs
│ │ │ ├── power_of_2.rs
│ │ │ ├── root.rs
│ │ │ ├── round_to_multiple.rs
│ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ ├── shl.rs
│ │ │ ├── shl_round.rs
│ │ │ ├── shr.rs
│ │ │ ├── shr_round.rs
│ │ │ ├── sign.rs
│ │ │ ├── sqrt.rs
│ │ │ ├── square.rs
│ │ │ ├── sub.rs
│ │ │ └── sub_mul.rs
│ │ ├── basic/
│ │ │ ├── constants.rs
│ │ │ ├── default.rs
│ │ │ ├── from_sign_and_abs.rs
│ │ │ ├── named.rs
│ │ │ └── size.rs
│ │ ├── comparison/
│ │ │ ├── cmp.rs
│ │ │ ├── cmp_abs.rs
│ │ │ ├── eq.rs
│ │ │ ├── eq_abs.rs
│ │ │ ├── eq_abs_natural.rs
│ │ │ ├── eq_abs_primitive_float.rs
│ │ │ ├── eq_abs_primitive_int.rs
│ │ │ ├── hash.rs
│ │ │ ├── partial_cmp_abs_natural.rs
│ │ │ ├── partial_cmp_abs_primitive_float.rs
│ │ │ ├── partial_cmp_abs_primitive_int.rs
│ │ │ ├── partial_cmp_natural.rs
│ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ ├── partial_eq_natural.rs
│ │ │ ├── partial_eq_primitive_float.rs
│ │ │ └── partial_eq_primitive_int.rs
│ │ ├── conversion/
│ │ │ ├── clone.rs
│ │ │ ├── from_bool.rs
│ │ │ ├── from_natural.rs
│ │ │ ├── from_primitive_float.rs
│ │ │ ├── from_primitive_int.rs
│ │ │ ├── from_twos_complement_limbs.rs
│ │ │ ├── is_integer.rs
│ │ │ ├── natural_from_integer.rs
│ │ │ ├── primitive_float_from_integer.rs
│ │ │ ├── primitive_int_from_integer.rs
│ │ │ ├── serde.rs
│ │ │ ├── string/
│ │ │ │ ├── from_sci_string.rs
│ │ │ │ ├── from_string.rs
│ │ │ │ ├── to_sci.rs
│ │ │ │ └── to_string.rs
│ │ │ └── to_twos_complement_limbs.rs
│ │ ├── exhaustive/
│ │ │ ├── exhaustive_integer_inclusive_range.rs
│ │ │ ├── exhaustive_integer_range.rs
│ │ │ ├── exhaustive_integer_range_to_infinity.rs
│ │ │ ├── exhaustive_integer_range_to_negative_infinity.rs
│ │ │ ├── exhaustive_integers.rs
│ │ │ ├── exhaustive_natural_integers.rs
│ │ │ ├── exhaustive_negative_integers.rs
│ │ │ ├── exhaustive_nonzero_integers.rs
│ │ │ ├── exhaustive_positive_integers.rs
│ │ │ ├── integer_decreasing_range_to_negative_infinity.rs
│ │ │ ├── integer_increasing_inclusive_range.rs
│ │ │ ├── integer_increasing_range.rs
│ │ │ └── integer_increasing_range_to_infinity.rs
│ │ ├── logic/
│ │ │ ├── and.rs
│ │ │ ├── assign_bit.rs
│ │ │ ├── assign_bits.rs
│ │ │ ├── bits.rs
│ │ │ ├── checked_count_ones.rs
│ │ │ ├── checked_count_zeros.rs
│ │ │ ├── checked_hamming_distance.rs
│ │ │ ├── clear_bit.rs
│ │ │ ├── flip_bit.rs
│ │ │ ├── from_bits.rs
│ │ │ ├── get_bit.rs
│ │ │ ├── get_bits.rs
│ │ │ ├── index_of_next_false_bit.rs
│ │ │ ├── index_of_next_true_bit.rs
│ │ │ ├── low_mask.rs
│ │ │ ├── not.rs
│ │ │ ├── or.rs
│ │ │ ├── set_bit.rs
│ │ │ ├── significant_bits.rs
│ │ │ ├── to_bits.rs
│ │ │ ├── trailing_zeros.rs
│ │ │ └── xor.rs
│ │ └── random/
│ │ ├── get_random_integer_from_range_to_infinity.rs
│ │ ├── get_random_integer_from_range_to_negative_infinity.rs
│ │ ├── get_striped_random_integer_from_inclusive_range.rs
│ │ ├── get_striped_random_integer_from_range.rs
│ │ ├── get_striped_random_integer_from_range_to_infinity.rs
│ │ ├── get_striped_random_integer_from_range_to_negative_infinity.rs
│ │ ├── get_uniform_random_integer_from_inclusive_range.rs
│ │ ├── get_uniform_random_integer_from_range.rs
│ │ ├── random_integer_inclusive_range.rs
│ │ ├── random_integer_range.rs
│ │ ├── random_integer_range_to_infinity.rs
│ │ ├── random_integer_range_to_negative_infinity.rs
│ │ ├── random_integers.rs
│ │ ├── random_natural_integers.rs
│ │ ├── random_negative_integers.rs
│ │ ├── random_nonzero_integers.rs
│ │ ├── random_positive_integers.rs
│ │ ├── striped_random_integer_inclusive_range.rs
│ │ ├── striped_random_integer_range.rs
│ │ ├── striped_random_integer_range_to_infinity.rs
│ │ ├── striped_random_integer_range_to_negative_infinity.rs
│ │ ├── striped_random_integers.rs
│ │ ├── striped_random_natural_integers.rs
│ │ ├── striped_random_negative_integers.rs
│ │ ├── striped_random_nonzero_integers.rs
│ │ ├── striped_random_positive_integers.rs
│ │ ├── uniform_random_integer_inclusive_range.rs
│ │ └── uniform_random_integer_range.rs
│ ├── lib.rs
│ └── natural/
│ ├── arithmetic/
│ │ ├── abs_diff.rs
│ │ ├── add.rs
│ │ ├── add_mul.rs
│ │ ├── binomial_coefficient.rs
│ │ ├── checked_sub.rs
│ │ ├── checked_sub_mul.rs
│ │ ├── coprime_with.rs
│ │ ├── div.rs
│ │ ├── div_exact.rs
│ │ ├── div_mod.rs
│ │ ├── div_round.rs
│ │ ├── divisible_by.rs
│ │ ├── divisible_by_power_of_2.rs
│ │ ├── eq_mod.rs
│ │ ├── eq_mod_power_of_2.rs
│ │ ├── extended_gcd.rs
│ │ ├── factorial.rs
│ │ ├── gcd.rs
│ │ ├── is_power_of_2.rs
│ │ ├── kronecker_symbol.rs
│ │ ├── lcm.rs
│ │ ├── log_base.rs
│ │ ├── log_base_2.rs
│ │ ├── log_base_power_of_2.rs
│ │ ├── mod_add.rs
│ │ ├── mod_inverse.rs
│ │ ├── mod_is_reduced.rs
│ │ ├── mod_mul.rs
│ │ ├── mod_neg.rs
│ │ ├── mod_op.rs
│ │ ├── mod_pow.rs
│ │ ├── mod_power_of_2.rs
│ │ ├── mod_power_of_2_add.rs
│ │ ├── mod_power_of_2_inverse.rs
│ │ ├── mod_power_of_2_is_reduced.rs
│ │ ├── mod_power_of_2_mul.rs
│ │ ├── mod_power_of_2_neg.rs
│ │ ├── mod_power_of_2_pow.rs
│ │ ├── mod_power_of_2_shl.rs
│ │ ├── mod_power_of_2_shr.rs
│ │ ├── mod_power_of_2_square.rs
│ │ ├── mod_power_of_2_sub.rs
│ │ ├── mod_shl.rs
│ │ ├── mod_shr.rs
│ │ ├── mod_square.rs
│ │ ├── mod_sub.rs
│ │ ├── mul.rs
│ │ ├── neg.rs
│ │ ├── next_power_of_2.rs
│ │ ├── parity.rs
│ │ ├── pow.rs
│ │ ├── power_of_2.rs
│ │ ├── primorial.rs
│ │ ├── root.rs
│ │ ├── round_to_multiple.rs
│ │ ├── round_to_multiple_of_power_of_2.rs
│ │ ├── saturating_sub.rs
│ │ ├── saturating_sub_mul.rs
│ │ ├── shl.rs
│ │ ├── shl_round.rs
│ │ ├── shr.rs
│ │ ├── shr_round.rs
│ │ ├── sign.rs
│ │ ├── sqrt.rs
│ │ ├── square.rs
│ │ ├── sub.rs
│ │ └── sub_mul.rs
│ ├── basic/
│ │ ├── constants.rs
│ │ ├── default.rs
│ │ ├── named.rs
│ │ └── size.rs
│ ├── comparison/
│ │ ├── cmp.rs
│ │ ├── eq.rs
│ │ ├── eq_abs_primitive_float.rs
│ │ ├── eq_abs_primitive_int.rs
│ │ ├── hash.rs
│ │ ├── partial_cmp_abs_primitive_float.rs
│ │ ├── partial_cmp_abs_primitive_int.rs
│ │ ├── partial_cmp_primitive_float.rs
│ │ ├── partial_cmp_primitive_int.rs
│ │ ├── partial_eq_primitive_float.rs
│ │ └── partial_eq_primitive_int.rs
│ ├── conversion/
│ │ ├── clone.rs
│ │ ├── digits/
│ │ │ ├── from_digits.rs
│ │ │ ├── from_power_of_2_digits.rs
│ │ │ ├── power_of_2_digits.rs
│ │ │ ├── to_digits.rs
│ │ │ └── to_power_of_2_digits.rs
│ │ ├── from_bool.rs
│ │ ├── from_limbs.rs
│ │ ├── from_primitive_float.rs
│ │ ├── from_primitive_int.rs
│ │ ├── is_integer.rs
│ │ ├── mantissa_and_exponent/
│ │ │ ├── integer_mantissa_and_exponent.rs
│ │ │ └── sci_mantissa_and_exponent.rs
│ │ ├── primitive_float_from_natural.rs
│ │ ├── primitive_int_from_natural.rs
│ │ ├── serde.rs
│ │ ├── string/
│ │ │ ├── from_sci_string.rs
│ │ │ ├── from_string.rs
│ │ │ ├── to_sci.rs
│ │ │ └── to_string.rs
│ │ └── to_limbs.rs
│ ├── exhaustive/
│ │ ├── exhaustive_natural_inclusive_range.rs
│ │ ├── exhaustive_natural_range.rs
│ │ ├── exhaustive_natural_range_to_infinity.rs
│ │ ├── exhaustive_naturals.rs
│ │ └── exhaustive_positive_naturals.rs
│ ├── factorization/
│ │ ├── is_power.rs
│ │ ├── is_square.rs
│ │ └── primes.rs
│ ├── logic/
│ │ ├── and.rs
│ │ ├── assign_bit.rs
│ │ ├── assign_bits.rs
│ │ ├── bits.rs
│ │ ├── clear_bit.rs
│ │ ├── count_ones.rs
│ │ ├── flip_bit.rs
│ │ ├── from_bits.rs
│ │ ├── get_bit.rs
│ │ ├── get_bits.rs
│ │ ├── hamming_distance.rs
│ │ ├── index_of_next_false_bit.rs
│ │ ├── index_of_next_true_bit.rs
│ │ ├── limb_count.rs
│ │ ├── low_mask.rs
│ │ ├── not.rs
│ │ ├── or.rs
│ │ ├── set_bit.rs
│ │ ├── significant_bits.rs
│ │ ├── to_bits.rs
│ │ ├── trailing_zeros.rs
│ │ └── xor.rs
│ └── random/
│ ├── get_random_natural_less_than.rs
│ ├── get_random_natural_with_bits.rs
│ ├── get_random_natural_with_up_to_bits.rs
│ ├── get_striped_random_natural_from_inclusive_range.rs
│ ├── get_striped_random_natural_from_range.rs
│ ├── get_striped_random_natural_with_bits.rs
│ ├── get_striped_random_natural_with_up_to_bits.rs
│ ├── random_natural_inclusive_range.rs
│ ├── random_natural_range.rs
│ ├── random_natural_range_to_infinity.rs
│ ├── random_naturals.rs
│ ├── random_naturals_less_than.rs
│ ├── random_positive_naturals.rs
│ ├── striped_random_natural_inclusive_range.rs
│ ├── striped_random_natural_range.rs
│ ├── striped_random_natural_range_to_infinity.rs
│ ├── striped_random_naturals.rs
│ ├── striped_random_positive_naturals.rs
│ ├── uniform_random_natural_inclusive_range.rs
│ └── uniform_random_natural_range.rs
├── malachite-q/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── README.md
│ ├── katex-header.html
│ ├── rustfmt.toml
│ ├── src/
│ │ ├── arithmetic/
│ │ │ ├── abs.rs
│ │ │ ├── abs_diff.rs
│ │ │ ├── add.rs
│ │ │ ├── approximate.rs
│ │ │ ├── ceiling.rs
│ │ │ ├── denominators_in_closed_interval.rs
│ │ │ ├── div.rs
│ │ │ ├── floor.rs
│ │ │ ├── is_power_of_2.rs
│ │ │ ├── log_base.rs
│ │ │ ├── log_base_2.rs
│ │ │ ├── log_base_power_of_2.rs
│ │ │ ├── mod.rs
│ │ │ ├── mod_op.rs
│ │ │ ├── mul.rs
│ │ │ ├── neg.rs
│ │ │ ├── next_power_of_2.rs
│ │ │ ├── pow.rs
│ │ │ ├── power_of_2.rs
│ │ │ ├── reciprocal.rs
│ │ │ ├── root.rs
│ │ │ ├── round_to_multiple.rs
│ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ ├── shl.rs
│ │ │ ├── shr.rs
│ │ │ ├── sign.rs
│ │ │ ├── simplest_rational_in_interval.rs
│ │ │ ├── sqrt.rs
│ │ │ ├── square.rs
│ │ │ ├── sub.rs
│ │ │ └── traits.rs
│ │ ├── bin.rs
│ │ ├── bin_util/
│ │ │ └── demo_and_bench/
│ │ │ ├── arithmetic/
│ │ │ │ ├── abs.rs
│ │ │ │ ├── abs_diff.rs
│ │ │ │ ├── add.rs
│ │ │ │ ├── approximate.rs
│ │ │ │ ├── ceiling.rs
│ │ │ │ ├── denominators_in_closed_interval.rs
│ │ │ │ ├── div.rs
│ │ │ │ ├── floor.rs
│ │ │ │ ├── is_power_of_2.rs
│ │ │ │ ├── log_base.rs
│ │ │ │ ├── log_base_2.rs
│ │ │ │ ├── log_base_power_of_2.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── mod_op.rs
│ │ │ │ ├── mul.rs
│ │ │ │ ├── neg.rs
│ │ │ │ ├── next_power_of_2.rs
│ │ │ │ ├── pow.rs
│ │ │ │ ├── power_of_2.rs
│ │ │ │ ├── reciprocal.rs
│ │ │ │ ├── root.rs
│ │ │ │ ├── round_to_multiple.rs
│ │ │ │ ├── round_to_multiple_of_power_of_2.rs
│ │ │ │ ├── shl.rs
│ │ │ │ ├── shr.rs
│ │ │ │ ├── sign.rs
│ │ │ │ ├── simplest_rational_in_interval.rs
│ │ │ │ ├── sqrt.rs
│ │ │ │ ├── square.rs
│ │ │ │ └── sub.rs
│ │ │ ├── basic/
│ │ │ │ ├── mod.rs
│ │ │ │ └── significant_bits.rs
│ │ │ ├── comparison/
│ │ │ │ ├── cmp.rs
│ │ │ │ ├── cmp_abs.rs
│ │ │ │ ├── eq.rs
│ │ │ │ ├── eq_abs.rs
│ │ │ │ ├── eq_abs_integer.rs
│ │ │ │ ├── eq_abs_natural.rs
│ │ │ │ ├── eq_abs_primitive_float.rs
│ │ │ │ ├── eq_abs_primitive_int.rs
│ │ │ │ ├── hash.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── partial_cmp_abs_integer.rs
│ │ │ │ ├── partial_cmp_abs_natural.rs
│ │ │ │ ├── partial_cmp_abs_primitive_float.rs
│ │ │ │ ├── partial_cmp_abs_primitive_int.rs
│ │ │ │ ├── partial_cmp_integer.rs
│ │ │ │ ├── partial_cmp_natural.rs
│ │ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ │ ├── partial_eq_integer.rs
│ │ │ │ ├── partial_eq_natural.rs
│ │ │ │ ├── partial_eq_primitive_float.rs
│ │ │ │ └── partial_eq_primitive_int.rs
│ │ │ ├── conversion/
│ │ │ │ ├── clone.rs
│ │ │ │ ├── continued_fraction/
│ │ │ │ │ ├── convergents.rs
│ │ │ │ │ ├── from_continued_fraction.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── to_continued_fraction.rs
│ │ │ │ ├── digits/
│ │ │ │ │ ├── from_digits.rs
│ │ │ │ │ ├── from_power_of_2_digits.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── to_digits.rs
│ │ │ │ │ └── to_power_of_2_digits.rs
│ │ │ │ ├── from_bool.rs
│ │ │ │ ├── from_float_simplest.rs
│ │ │ │ ├── from_integer.rs
│ │ │ │ ├── from_natural.rs
│ │ │ │ ├── from_numerator_and_denominator.rs
│ │ │ │ ├── from_primitive_float.rs
│ │ │ │ ├── from_primitive_int.rs
│ │ │ │ ├── integer_from_rational.rs
│ │ │ │ ├── is_integer.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── mutate_numerator_or_denominator.rs
│ │ │ │ ├── natural_from_rational.rs
│ │ │ │ ├── primitive_float_from_rational.rs
│ │ │ │ ├── primitive_int_from_rational.rs
│ │ │ │ ├── sci_mantissa_and_exponent.rs
│ │ │ │ ├── serde.rs
│ │ │ │ ├── string/
│ │ │ │ │ ├── from_sci_string.rs
│ │ │ │ │ ├── from_string.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── to_sci.rs
│ │ │ │ │ └── to_string.rs
│ │ │ │ └── to_numerator_or_denominator.rs
│ │ │ └── mod.rs
│ │ ├── comparison/
│ │ │ ├── cmp.rs
│ │ │ ├── cmp_abs.rs
│ │ │ ├── eq_abs.rs
│ │ │ ├── eq_abs_integer.rs
│ │ │ ├── eq_abs_natural.rs
│ │ │ ├── eq_abs_primitive_float.rs
│ │ │ ├── eq_abs_primitive_int.rs
│ │ │ ├── mod.rs
│ │ │ ├── partial_cmp_abs_integer.rs
│ │ │ ├── partial_cmp_abs_natural.rs
│ │ │ ├── partial_cmp_abs_primitive_float.rs
│ │ │ ├── partial_cmp_abs_primitive_int.rs
│ │ │ ├── partial_cmp_integer.rs
│ │ │ ├── partial_cmp_natural.rs
│ │ │ ├── partial_cmp_primitive_float.rs
│ │ │ ├── partial_cmp_primitive_int.rs
│ │ │ ├── partial_eq_integer.rs
│ │ │ ├── partial_eq_natural.rs
│ │ │ ├── partial_eq_primitive_float.rs
│ │ │ └── partial_eq_primitive_int.rs
│ │ ├── conversion/
│ │ │ ├── continued_fraction/
│ │ │ │ ├── convergents.rs
│ │ │ │ ├── from_continued_fraction.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── to_continued_fraction.rs
│ │ │ ├── digits/
│ │ │ │ ├── digits.rs
│ │ │ │ ├── from_digits.rs
│ │ │ │ ├── from_power_of_2_digits.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── power_of_2_digits.rs
│ │ │ │ ├── to_digits.rs
│ │ │ │ └── to_power_of_2_digits.rs
│ │ │ ├── from_bool.rs
│ │ │ ├── from_float_simplest.rs
│ │ │ ├── from_integer.rs
│ │ │ ├── from_natural.rs
│ │ │ ├── from_numerator_and_denominator.rs
│ │ │ ├── from_primitive_float.rs
│ │ │ ├── from_primitive_int.rs
│ │ │ ├── integer_from_rational.rs
│ │ │ ├── is_integer.rs
│ │ │ ├── mantissa_and_exponent.rs
│ │ │ ├── mod.rs
│ │ │ ├── mutate_numerator_and_denominator.rs
│ │ │ ├── natural_from_rational.rs
│ │ │ ├── primitive_float_from_rational.rs
│ │ │ ├── primitive_int_from_rational.rs
│ │ │ ├── string/
│ │ │ │ ├── from_sci_string.rs
│ │ │ │ ├── from_string.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── to_sci.rs
│ │ │ │ └── to_string.rs
│ │ │ ├── to_numerator_and_denominator.rs
│ │ │ └── traits.rs
│ │ ├── exhaustive/
│ │ │ └── mod.rs
│ │ ├── lib.rs
│ │ ├── random/
│ │ │ └── mod.rs
│ │ └── test_util/
│ │ ├── arithmetic/
│ │ │ ├── add.rs
│ │ │ ├── approximate.rs
│ │ │ ├── div.rs
│ │ │ ├── mod.rs
│ │ │ ├── mod_op.rs
│ │ │ ├── mul.rs
│ │ │ ├── sign.rs
│ │ │ ├── simplest_rational_in_interval.rs
│ │ │ └── sub.rs
│ │ ├── bench/
│ │ │ ├── bucketers.rs
│ │ │ └── mod.rs
│ │ ├── common/
│ │ │ └── mod.rs
│ │ ├── conversion/
│ │ │ ├── continued_fraction/
│ │ │ │ ├── convergents.rs
│ │ │ │ ├── from_continued_fraction.rs
│ │ │ │ └── mod.rs
│ │ │ └── mod.rs
│ │ ├── extra_variadic/
│ │ │ └── mod.rs
│ │ ├── generators/
│ │ │ ├── common.rs
│ │ │ ├── exhaustive.rs
│ │ │ ├── mod.rs
│ │ │ ├── random.rs
│ │ │ └── special_random.rs
│ │ ├── mod.rs
│ │ └── random/
│ │ └── mod.rs
│ └── tests/
│ ├── arithmetic/
│ │ ├── abs.rs
│ │ ├── abs_diff.rs
│ │ ├── add.rs
│ │ ├── approximate.rs
│ │ ├── ceiling.rs
│ │ ├── denominators_in_closed_interval.rs
│ │ ├── div.rs
│ │ ├── floor.rs
│ │ ├── is_power_of_2.rs
│ │ ├── log_base.rs
│ │ ├── log_base_2.rs
│ │ ├── log_base_power_of_2.rs
│ │ ├── mod_op.rs
│ │ ├── mul.rs
│ │ ├── neg.rs
│ │ ├── next_power_of_2.rs
│ │ ├── pow.rs
│ │ ├── power_of_2.rs
│ │ ├── reciprocal.rs
│ │ ├── root.rs
│ │ ├── round_to_multiple.rs
│ │ ├── round_to_multiple_of_power_of_2.rs
│ │ ├── shl.rs
│ │ ├── shr.rs
│ │ ├── sign.rs
│ │ ├── simplest_rational_in_interval.rs
│ │ ├── sqrt.rs
│ │ ├── square.rs
│ │ └── sub.rs
│ ├── basic/
│ │ ├── constants.rs
│ │ ├── default.rs
│ │ ├── named.rs
│ │ ├── significant_bits.rs
│ │ └── size.rs
│ ├── comparison/
│ │ ├── cmp.rs
│ │ ├── cmp_abs.rs
│ │ ├── eq.rs
│ │ ├── eq_abs.rs
│ │ ├── eq_abs_integer.rs
│ │ ├── eq_abs_natural.rs
│ │ ├── eq_abs_primitive_float.rs
│ │ ├── eq_abs_primitive_int.rs
│ │ ├── hash.rs
│ │ ├── partial_cmp_abs_integer.rs
│ │ ├── partial_cmp_abs_natural.rs
│ │ ├── partial_cmp_abs_primitive_float.rs
│ │ ├── partial_cmp_abs_primitive_int.rs
│ │ ├── partial_cmp_integer.rs
│ │ ├── partial_cmp_natural.rs
│ │ ├── partial_cmp_primitive_float.rs
│ │ ├── partial_cmp_primitive_int.rs
│ │ ├── partial_eq_integer.rs
│ │ ├── partial_eq_natural.rs
│ │ ├── partial_eq_primitive_float.rs
│ │ └── partial_eq_primitive_int.rs
│ ├── conversion/
│ │ ├── clone.rs
│ │ ├── continued_fraction/
│ │ │ ├── convergents.rs
│ │ │ ├── from_continued_fraction.rs
│ │ │ └── to_continued_fraction.rs
│ │ ├── digits/
│ │ │ ├── digits.rs
│ │ │ ├── from_digits.rs
│ │ │ ├── from_power_of_2_digits.rs
│ │ │ ├── power_of_2_digits.rs
│ │ │ ├── to_digits.rs
│ │ │ └── to_power_of_2_digits.rs
│ │ ├── from_bool.rs
│ │ ├── from_float_simplest.rs
│ │ ├── from_integer.rs
│ │ ├── from_natural.rs
│ │ ├── from_numerator_and_denominator.rs
│ │ ├── from_primitive_float.rs
│ │ ├── from_primitive_int.rs
│ │ ├── integer_from_rational.rs
│ │ ├── is_integer.rs
│ │ ├── mutate_numerator_or_denominator.rs
│ │ ├── natural_from_rational.rs
│ │ ├── primitive_float_from_rational.rs
│ │ ├── primitive_int_from_rational.rs
│ │ ├── sci_mantissa_and_exponent.rs
│ │ ├── serde.rs
│ │ ├── string/
│ │ │ ├── from_sci_string.rs
│ │ │ ├── from_string.rs
│ │ │ ├── to_sci.rs
│ │ │ └── to_string.rs
│ │ └── to_numerator_or_denominator.rs
│ ├── exhaustive/
│ │ ├── exhaustive_negative_rationals.rs
│ │ ├── exhaustive_non_negative_rationals.rs
│ │ ├── exhaustive_nonzero_rationals.rs
│ │ ├── exhaustive_positive_rationals.rs
│ │ ├── exhaustive_rational_inclusive_range.rs
│ │ ├── exhaustive_rational_range.rs
│ │ ├── exhaustive_rational_range_to_infinity.rs
│ │ ├── exhaustive_rational_range_to_negative_infinity.rs
│ │ ├── exhaustive_rationals.rs
│ │ ├── exhaustive_rationals_with_denominator_inclusive_range.rs
│ │ ├── exhaustive_rationals_with_denominator_range.rs
│ │ ├── exhaustive_rationals_with_denominator_range_to_infinity.rs
│ │ └── exhaustive_rationals_with_denominator_range_to_negative_infinity.rs
│ ├── lib.rs
│ └── random/
│ ├── random_negative_rationals.rs
│ ├── random_non_negative_rationals.rs
│ ├── random_nonzero_rationals.rs
│ ├── random_positive_rationals.rs
│ ├── random_rational_inclusive_range.rs
│ ├── random_rational_range.rs
│ ├── random_rational_range_to_infinity.rs
│ ├── random_rational_range_to_negative_infinity.rs
│ ├── random_rational_with_denominator_inclusive_range.rs
│ ├── random_rational_with_denominator_range.rs
│ ├── random_rational_with_denominator_range_to_infinity.rs
│ ├── random_rational_with_denominator_range_to_negative_infinity.rs
│ ├── random_rationals.rs
│ ├── striped_random_negative_rationals.rs
│ ├── striped_random_non_negative_rationals.rs
│ ├── striped_random_nonzero_rationals.rs
│ ├── striped_random_positive_rationals.rs
│ ├── striped_random_rational_range_to_infinity.rs
│ ├── striped_random_rational_range_to_negative_infinity.rs
│ └── striped_random_rationals.rs
├── rundoc.sh
└── superfmt.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .envrc
================================================
if ! has nix_direnv_version || ! nix_direnv_version 2.3.0; then
source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/2.3.0/direnvrc" "sha256-Dmd+j63L84wuzgyjITIfSxSD57Tx7v51DMxVZOsiUD8="
fi
use flake
# vi: ft=sh
================================================
FILE: .github/FUNDING.yml
================================================
github: mhogrefe
================================================
FILE: .github/workflows/rust.yml
================================================
name: Rust
on:
push:
branches: [ "master" ]
pull_request:
branches: [ "master" ]
env:
CARGO_TERM_COLOR: always
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Build
run: cargo build --verbose
- name: Run tests
run: cargo test --release --verbose
================================================
FILE: .gitignore
================================================
target
*.bk
.idea*
*.iml
src/integer_old.rs
*.DS_Store
*/.vscode/*
*.history/*
*/.history/*
.direnv/
================================================
FILE: .vscode/launch.json
================================================
{
"version": "0.2.0",
"configurations": [
{
"name": "malachite-nz-test-util",
"type": "lldb",
"request": "launch",
"program": "${workspaceRoot}/malachite-nz-test-util/target/debug/malachite_nz_test_util_main",
"args": ["-l 10000 -m exhaustive -d demo_natural_mul"],
"cwd": "${workspaceRoot}",
"stopOnEntry": false,
}
]
}
================================================
FILE: .vscode/tasks.json
================================================
{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
{
"label": "malachite-base: check",
"type": "shell",
"command": "cargo check --all-targets",
"options": {
"cwd": "${workspaceFolder}/malachite-base"
}
},
{
"label": "malachite-base: clippy",
"type": "shell",
"command": "cargo clippy --all-targets",
"options": {
"cwd": "${workspaceFolder}/malachite-base"
}
},
{
"label": "malachite-base: fmt",
"type": "shell",
"command": "cargo fmt",
"options": {
"cwd": "${workspaceFolder}/malachite-base"
}
},
{
"label": "malachite-base: doc",
"type": "shell",
"command": "cargo doc --no-deps",
"options": {
"cwd": "${workspaceFolder}/malachite-base",
"env": {
"RUSTDOCFLAGS": "--html-in-header katex-header.html"
}
}
},
{
"label": "malachite-base: open docs",
"type": "shell",
"command": "open target/doc/malachite_base/index.html",
"options": {
"cwd": "${workspaceFolder}/malachite-base",
}
},
{
"label": "malachite-base-test-util: check",
"type": "shell",
"command": "cargo check --all-targets",
"options": {
"cwd": "${workspaceFolder}/malachite-base-test-util"
}
},
{
"label": "malachite-base-test-util: clippy",
"type": "shell",
"command": "cargo clippy --all-targets",
"options": {
"cwd": "${workspaceFolder}/malachite-base-test-util"
}
},
{
"label": "malachite-base-test-util: fmt",
"type": "shell",
"command": "cargo fmt",
"options": {
"cwd": "${workspaceFolder}/malachite-base-test-util"
}
},
{
"label": "malachite-nz 32: check",
"type": "shell",
"command": "cargo check --all-targets --features 32_bit_limbs",
"options": {
"cwd": "${workspaceFolder}/malachite-nz"
}
},
{
"label": "malachite-nz 32: clippy",
"type": "shell",
"command": "cargo clippy --all-targets --features 32_bit_limbs",
"options": {
"cwd": "${workspaceFolder}/malachite-nz"
}
},
{
"label": "malachite-nz 64: check",
"type": "shell",
"command": "cargo check --all-targets",
"options": {
"cwd": "${workspaceFolder}/malachite-nz"
}
},
{
"label": "malachite-nz 64: clippy",
"type": "shell",
"command": "cargo clippy --all-targets",
"options": {
"cwd": "${workspaceFolder}/malachite-nz"
}
},
{
"label": "malachite-nz: fmt",
"type": "shell",
"command": "cargo fmt",
"options": {
"cwd": "${workspaceFolder}/malachite-nz"
}
},
{
"label": "malachite-nz: doc",
"type": "shell",
"command": "cargo doc --no-deps",
"options": {
"cwd": "${workspaceFolder}/malachite-nz",
"env": {
"RUSTDOCFLAGS": "--html-in-header katex-header.html"
}
}
},
{
"label": "malachite-nz: open docs",
"type": "shell",
"command": "open target/doc/malachite_nz/index.html",
"options": {
"cwd": "${workspaceFolder}/malachite-nz",
}
},
{
"label": "malachite-nz-test-util: check",
"type": "shell",
"command": "cargo check --all-targets",
"options": {
"cwd": "${workspaceFolder}/malachite-nz-test-util"
}
},
{
"label": "malachite-nz-test-util: clippy",
"type": "shell",
"command": "cargo clippy --all-targets",
"options": {
"cwd": "${workspaceFolder}/malachite-nz-test-util"
}
},
{
"label": "malachite-nz-test-util: fmt",
"type": "shell",
"command": "cargo fmt",
"options": {
"cwd": "${workspaceFolder}/malachite-nz-test-util"
}
},
]
}
================================================
FILE: COPYING
================================================
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program 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 3 of the License, or
(at your option) any later version.
This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<https://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<https://www.gnu.org/licenses/why-not-lgpl.html>.
================================================
FILE: COPYING.LESSER
================================================
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
================================================
FILE: Cargo.toml
================================================
[workspace]
members = ['malachite', 'malachite-base', 'malachite-bigint', 'malachite-float', 'malachite-nz', 'malachite-q', 'malachite-criterion-bench']
resolver = "2"
[workspace.package]
edition = "2024"
rust-version = "1.90.0"
[workspace.dependencies]
malachite-base = { version = "0.9.1", path = 'malachite-base', default-features = false }
malachite-nz = { version = "0.9.1", path = 'malachite-nz', default-features = false }
malachite-q = { version = "0.9.1", path = 'malachite-q', default-features = false }
malachite-float = { version = "0.9.1", path = 'malachite-float', default-features = false }
[profile.release]
lto = "fat"
strip = true
codegen-units = 1
================================================
FILE: LICENSE
================================================
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
================================================
FILE: README.md
================================================
<img width="500" src="docs/assets/logo-and-name.svg" alt="Logo">
An arbitrary-precision arithmetic library for Rust.
Parts of Malachite are derived from [GMP](https://gmplib.org/),
[FLINT](https://www.flintlib.org/), and [MPFR](https://www.mpfr.org/).
The documentation for Malachite is [here](https://docs.rs/malachite/latest/malachite/), and its crate is [here](https://crates.io/crates/malachite).
Floats (arbitrary-precision floating-point numbers) are in development and are currently experimental. They are missing many important functions. However, the floating-point functions that *are* currently implemented are thoroughly tested and documented, with the exception of string conversion functions. The current floating-point string conversion functions are incomplete and will be changed in the future to match MPFR's behavior.
Malachite is developed by Mikhail Hogrefe. Thanks to 43615, b4D8, coolreader18, Dasaav-dsv, Duncan Freeman, florian1345, konstin, Rowan Hart, YunWon Jeong, Park Joon-Kyu, Antonio Mamić, OliverNChalk, Kevin Phoenix, probablykasper, shekohex, skycloudd, John Vandenberg, Brandon Weeks, and Will Youmans for additional contributions.
<https://malachite.rs/>
Copyright © 2026 Mikhail Hogrefe
================================================
FILE: _config.yml
================================================
theme: jekyll-theme-cayman
================================================
FILE: additional-lints.py
================================================
import os
MAX_LINE_LENGTH = 100
line_length_exceptions = set((
# long Markdown table rows and/or links
('./malachite-base/src/lib.rs', 65),
('./malachite-base/src/num/arithmetic/mod.rs', 339),
('./malachite-base/src/num/arithmetic/mod.rs', 340),
('./malachite-base/src/num/arithmetic/mod.rs', 1340),
('./malachite-base/src/num/arithmetic/mod.rs', 1580),
('./malachite-base/src/num/arithmetic/mod.rs', 1581),
('./malachite-base/src/num/arithmetic/mod.rs', 1582),
('./malachite-base/src/num/arithmetic/mod.rs', 1583),
('./malachite-base/src/num/arithmetic/primorial.rs', 85),
('./malachite-base/src/num/arithmetic/primorial.rs', 244),
('./malachite-base/src/num/arithmetic/round_to_multiple_of_power_of_2.rs', 118),
('./malachite-base/src/num/conversion/digits/power_of_2_digit_iterable.rs', 153),
('./malachite-base/src/num/conversion/digits/power_of_2_digit_iterable.rs', 155),
('./malachite-base/src/num/exhaustive/mod.rs', 1074),
('./malachite-float/src/conversion/mantissa_and_exponent.rs', 478),
('./malachite-float/src/conversion/mantissa_and_exponent.rs', 682),
('./malachite-float/src/conversion/mod.rs', 227),
('./malachite-float/src/lib.rs', 24),
('./malachite-nz/src/integer/arithmetic/mod.rs', 39),
('./malachite-nz/src/integer/arithmetic/mod.rs', 40),
('./malachite-nz/src/integer/arithmetic/mod.rs', 41),
('./malachite-nz/src/integer/arithmetic/mod.rs', 76),
('./malachite-nz/src/integer/arithmetic/mod.rs', 77),
('./malachite-nz/src/integer/arithmetic/mod.rs', 88),
('./malachite-nz/src/integer/arithmetic/mod.rs', 89),
('./malachite-nz/src/integer/arithmetic/mod.rs', 90),
('./malachite-nz/src/integer/arithmetic/mod.rs', 119),
('./malachite-nz/src/integer/arithmetic/mod.rs', 121),
('./malachite-nz/src/lib.rs', 36),
('./malachite-nz/src/lib.rs', 103),
('./malachite-nz/src/natural/arithmetic/mod.rs', 46),
('./malachite-nz/src/natural/arithmetic/mod.rs', 47),
('./malachite-nz/src/natural/arithmetic/mod.rs', 48),
('./malachite-nz/src/natural/arithmetic/mod.rs', 162),
('./malachite-nz/src/natural/arithmetic/mod.rs', 163),
('./malachite-nz/src/natural/arithmetic/mod.rs', 186),
('./malachite-nz/src/natural/arithmetic/mod.rs', 187),
('./malachite-nz/src/natural/arithmetic/mod.rs', 188),
('./malachite-nz/src/natural/arithmetic/mod.rs', 571),
('./malachite-nz/src/natural/arithmetic/mod.rs', 573),
('./malachite-nz/src/natural/conversion/digits/power_of_2_digit_iterable.rs', 526),
('./malachite-nz/src/natural/conversion/digits/power_of_2_digit_iterable.rs', 528),
('./malachite-nz/src/natural/conversion/digits/power_of_2_digit_iterable.rs', 827),
('./malachite-nz/src/natural/conversion/digits/power_of_2_digit_iterable.rs', 829),
('./malachite-nz/src/natural/conversion/mantissa_and_exponent.rs', 323),
('./malachite-nz/src/natural/conversion/mantissa_and_exponent.rs', 508),
('./malachite-nz/src/natural/conversion/mod.rs', 257),
('./malachite-q/src/arithmetic/mod.rs', 63),
('./malachite-q/src/arithmetic/mod.rs', 64),
('./malachite-q/src/arithmetic/mod.rs', 95),
('./malachite-q/src/arithmetic/mod.rs', 97),
('./malachite-q/src/conversion/string/from_sci_string.rs', 145),
('./malachite-q/src/conversion/string/from_sci_string.rs', 232),
('./malachite-q/src/lib.rs', 54),
))
def lint(filename):
i = 1
with open(filename) as f:
for line in f.readlines():
line = line.rstrip()
is_exception = (filename, i) in line_length_exceptions
if is_exception:
if len(line) <= MAX_LINE_LENGTH:
raise ValueError(f'line not too long: {filename}: {i} {line}')
elif len(line) > MAX_LINE_LENGTH:
raise ValueError(f'line too long: {filename}: {i} {line}')
i += 1
return i - 1
filename_list = []
for root, directories, filenames in os.walk('.'):
for filename in filenames:
filename = os.path.join(root, filename)
if '/target/' not in filename and '.history' not in filename and filename.endswith('.rs'):
filename_list.append(filename)
filename_list.sort()
line_count = 0
for filename in filename_list:
line_count += lint(filename)
print(f'{line_count} lines checked')
================================================
FILE: build.sh
================================================
#!/bin/bash
echo "Step 1. Checking for updates" &&
rustup update &&
echo "Step 2. Updating headers" &&
cd ../fix-headers &&
cargo test --release &&
cd ../malachite/malachite-base &&
echo "Step 3. Formatting malachite-base" &&
bash ../superfmt.sh &&
echo "Step 4. Checking malachite-base lib" &&
cargo check --lib &&
echo "Step 5. Checking malachite-base lib with random" &&
cargo check --lib --features random &&
echo "Step 6. Checking all malachite-base targets with bin_build" &&
cargo check --all-targets --features bin_build &&
echo "Step 7. Checking malachite-base lib with no std" &&
cargo check --lib --no-default-features &&
echo "Step 8. Checking malachite-base lib with random and no std" &&
cargo check --lib --features random --no-default-features &&
echo "Step 9. Checking all malachite-base targets with bin_build and no std" &&
cargo check --all-targets --features bin_build --no-default-features &&
cd ../malachite-nz &&
echo "Step 10. Formatting malachite-nz" &&
bash ../superfmt.sh &&
echo "Step 11. Checking malachite-nz lib with 32_bit_limbs" &&
cargo check --lib --features 32_bit_limbs &&
echo "Step 12. Checking malachite-nz lib" &&
cargo check --lib &&
echo "Step 13. Checking malachite-nz lib with 32_bit_limbs and random" &&
cargo check --lib --features 32_bit_limbs --features random &&
echo "Step 14. Checking malachite-nz lib with random" &&
cargo check --lib --features random &&
echo "Step 15. Checking malachite-nz lib with 32_bit_limbs and serde" &&
cargo check --lib --features 32_bit_limbs --features enable_serde &&
echo "Step 16. Checking malachite-nz lib with serde" &&
cargo check --lib --features enable_serde &&
echo "Step 17. Checking malachite-nz lib with 32_bit_limbs, serde, and random" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --features random &&
echo "Step 18. Checking malachite-nz lib with serde and random" &&
cargo check --lib --features enable_serde --features random &&
echo "Step 19. Checking all malachite-nz targets with bin_build, 32_bit_limbs, and serde" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde &&
echo "Step 20. Checking all malachite-nz targets with bin_build and serde" &&
cargo check --all-targets --features bin_build --features enable_serde &&
echo "Step 21. Checking all malachite-nz targets with bin_build, 32_bit_limbs, serde, and random" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --features random &&
echo "Step 22. Checking all malachite-nz targets with bin_build, serde, and random" &&
cargo check --all-targets --features bin_build --features enable_serde --features random &&
echo "Step 23. Checking malachite-nz lib with 32_bit_limbs and no std" &&
cargo check --lib --features 32_bit_limbs --no-default-features &&
echo "Step 24. Checking malachite-nz lib with no std" &&
cargo check --lib --no-default-features &&
echo "Step 25. Checking malachite-nz lib with 32_bit_limbs and random and no std" &&
cargo check --lib --features 32_bit_limbs --features random --no-default-features &&
echo "Step 26. Checking malachite-nz lib with random and no std" &&
cargo check --lib --features random --no-default-features &&
echo "Step 27. Checking malachite-nz lib with 32_bit_limbs and serde and no std" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --no-default-features &&
echo "Step 28. Checking malachite-nz lib with serde and no std" &&
cargo check --lib --features enable_serde --no-default-features &&
echo "Step 29. Checking malachite-nz lib with 32_bit_limbs, serde, and random and no std" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --features random --no-default-features &&
echo "Step 30. Checking malachite-nz lib with serde and random and no std" &&
cargo check --lib --features enable_serde --features random --no-default-features &&
echo "Step 31. Checking all malachite-nz targets with bin_build, 32_bit_limbs, and serde and no std" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --no-default-features &&
echo "Step 32. Checking all malachite-nz targets with bin_build and serde and no std" &&
cargo check --all-targets --features bin_build --features enable_serde --no-default-features &&
echo "Step 33. Checking all malachite-nz targets with bin_build, 32_bit_limbs, serde, and random and no std" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --features random --no-default-features &&
echo "Step 34. Checking all malachite-nz targets with bin_build, serde, and random and no std" &&
cargo check --all-targets --features bin_build --features enable_serde --features random --no-default-features &&
cd ../malachite-q &&
echo "Step 35. Formatting malachite-q" &&
bash ../superfmt.sh &&
echo "Step 36. Checking malachite-q lib with 32_bit_limbs" &&
cargo check --lib --features 32_bit_limbs &&
echo "Step 37. Checking malachite-q lib" &&
cargo check --lib &&
echo "Step 38. Checking malachite-q lib with 32_bit_limbs and random" &&
cargo check --lib --features 32_bit_limbs --features random &&
echo "Step 39. Checking malachite-q lib with random" &&
cargo check --lib --features random &&
echo "Step 40. Checking malachite-q lib with 32_bit_limbs and serde" &&
cargo check --lib --features 32_bit_limbs --features enable_serde &&
echo "Step 41. Checking malachite-q lib with serde" &&
cargo check --lib --features enable_serde &&
echo "Step 42. Checking malachite-q lib with 32_bit_limbs, serde, and random" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --features random &&
echo "Step 43. Checking malachite-q lib with serde and random" &&
cargo check --lib --features enable_serde --features random &&
echo "Step 44. Checking all malachite-q targets with bin_build, 32_bit_limbs, and serde" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde &&
echo "Step 45. Checking all malachite-q targets with bin_build and serde" &&
cargo check --all-targets --features bin_build --features enable_serde &&
echo "Step 46. Checking all malachite-q targets with bin_build, 32_bit_limbs, serde, and random" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --features random &&
echo "Step 47. Checking all malachite-q targets with bin_build, serde, and random" &&
cargo check --all-targets --features bin_build --features enable_serde --features random &&
echo "Step 48. Checking malachite-q lib with 32_bit_limbs and no std" &&
cargo check --lib --features 32_bit_limbs --no-default-features &&
echo "Step 49. Checking malachite-q lib with no std" &&
cargo check --lib --no-default-features &&
echo "Step 50. Checking malachite-q lib with 32_bit_limbs and random and no std" &&
cargo check --lib --features 32_bit_limbs --features random --no-default-features &&
echo "Step 51. Checking malachite-q lib with random and no std" &&
cargo check --lib --features random --no-default-features &&
echo "Step 52. Checking malachite-q lib with 32_bit_limbs and serde and no std" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --no-default-features &&
echo "Step 53. Checking malachite-q lib with serde and no std" &&
cargo check --lib --features enable_serde --no-default-features &&
echo "Step 54. Checking malachite-q lib with 32_bit_limbs, serde, and random and no std" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --features random --no-default-features &&
echo "Step 55. Checking malachite-q lib with serde and random and no std" &&
cargo check --lib --features enable_serde --features random --no-default-features &&
echo "Step 56. Checking all malachite-q targets with bin_build, 32_bit_limbs, and serde and no std" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --no-default-features &&
echo "Step 57. Checking all malachite-q targets with bin_build and serde and no std" &&
cargo check --all-targets --features bin_build --features enable_serde --no-default-features &&
echo "Step 58. Checking all malachite-q targets with bin_build, 32_bit_limbs, serde, and random and no std" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --features random --no-default-features &&
echo "Step 59. Checking all malachite-q targets with bin_build, serde, and random and no std" &&
cargo check --all-targets --features bin_build --features enable_serde --features random --no-default-features &&
cd ../malachite-float &&
echo "Step 60. Formatting malachite-float" &&
bash ../superfmt.sh &&
echo "Step 61. Checking malachite-float lib with 32_bit_limbs" &&
cargo check --lib --features 32_bit_limbs &&
echo "Step 62. Checking malachite-float lib" &&
cargo check --lib &&
echo "Step 63. Checking malachite-float lib with 32_bit_limbs and random" &&
cargo check --lib --features 32_bit_limbs --features random &&
echo "Step 64. Checking malachite-float lib with random" &&
cargo check --lib --features random &&
echo "Step 65. Checking malachite-float lib with 32_bit_limbs and serde" &&
cargo check --lib --features 32_bit_limbs --features enable_serde &&
echo "Step 66. Checking malachite-float lib with serde" &&
cargo check --lib --features enable_serde &&
echo "Step 67. Checking malachite-float lib with 32_bit_limbs, serde, and random" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --features random &&
echo "Step 68. Checking malachite-float lib with serde and random" &&
cargo check --lib --features enable_serde --features random &&
echo "Step 69. Checking all malachite-float targets with bin_build, 32_bit_limbs, and serde" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde &&
echo "Step 70. Checking all malachite-float targets with bin_build and serde" &&
cargo check --all-targets --features bin_build --features enable_serde &&
echo "Step 71. Checking all malachite-float targets with bin_build, 32_bit_limbs, serde, and random" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --features random &&
echo "Step 72. Checking all malachite-float targets with bin_build, serde, and random" &&
cargo check --all-targets --features bin_build --features enable_serde --features random &&
echo "Step 73. Checking malachite-float lib with 32_bit_limbs and no std" &&
cargo check --lib --features 32_bit_limbs --no-default-features &&
echo "Step 74. Checking malachite-float lib with no std" &&
cargo check --lib --no-default-features &&
echo "Step 75. Checking malachite-float lib with 32_bit_limbs and random and no std" &&
cargo check --lib --features 32_bit_limbs --features random --no-default-features &&
echo "Step 76. Checking malachite-float lib with random and no std" &&
cargo check --lib --features random --no-default-features &&
echo "Step 77. Checking malachite-float lib with 32_bit_limbs and serde and no std" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --no-default-features &&
echo "Step 78. Checking malachite-float lib with serde and no std" &&
cargo check --lib --features enable_serde --no-default-features &&
echo "Step 79. Checking malachite-float lib with 32_bit_limbs, serde, and random and no std" &&
cargo check --lib --features 32_bit_limbs --features enable_serde --features random --no-default-features &&
echo "Step 80. Checking malachite-float lib with serde and random and no std" &&
cargo check --lib --features enable_serde --features random --no-default-features &&
echo "Step 81. Checking all malachite-float targets with bin_build, 32_bit_limbs, and serde no std" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --no-default-features &&
echo "Step 82. Checking all malachite-float targets with bin_build and serde and no std" &&
cargo check --all-targets --features bin_build --features enable_serde --no-default-features &&
echo "Step 83. Checking all malachite-float targets with bin_build, 32_bit_limbs, serde, and random and no std" &&
cargo check --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --features random --no-default-features &&
echo "Step 84. Checking all malachite-float targets with bin_build, serde, and random and no std" &&
cargo check --all-targets --features bin_build --features enable_serde --features random --no-default-features &&
cd ../malachite-criterion-bench &&
echo "Step 85. Formatting malachite-criterion-bench" &&
bash ../superfmt.sh &&
echo "Step 86. Checking malachite-criterion-bench" &&
cargo check &&
cd ../malachite-bigint &&
echo "Step 87. Formatting malachite-bigint" &&
bash ../superfmt.sh &&
echo "Step 88. Checking all malachite-bigint targets" &&
cargo check --all-targets &&
echo "Step 89. Checking all malachite-bigint targets with no std" &&
cargo check --all-targets --no-default-features &&
echo "Step 90. Checking the malachite meta-crate" &&
cd ../malachite &&
cargo check --all-targets &&
echo "Step 91. Checking the malachite meta-crate with serde" &&
cargo check --all-targets --features enable_serde &&
cd .. &&
echo "Step 92. Running additional-lints" &&
python3 additional-lints.py &&
cd malachite-base &&
echo "Step 93. Updating malachite-base" &&
cargo update &&
echo "Step 94. Formatting malachite-base" &&
bash ../superfmt.sh &&
echo "Step 95. Running clippy on malachite-base" &&
cargo clippy --all-targets --features bin_build &&
echo "Step 96. Running clippy on malachite-base with no std" &&
cargo clippy --all-targets --features bin_build --no-default-features &&
echo "Step 97. Testing malachite-base" &&
cargo test --release --tests --features bin_build &&
echo "Step 98. Testing malachite-base with no std" &&
cargo test --release --tests --features bin_build --no-default-features &&
echo "Step 99. Testing malachite-base doctests" &&
bash ../rundoc.sh --features test_build &&
echo "Step 100. Testing malachite-base doctests with random" &&
bash ../rundoc.sh --features test_build --features random &&
echo "Step 101. Documenting malachite-base" &&
RUSTDOCFLAGS="--html-in-header katex-header.html" cargo doc --lib --no-deps --features random &&
echo "Step 102. Building malachite-base lib for wasm" &&
cargo build --lib --release --target wasm32-unknown-unknown &&
cd ../malachite-nz &&
echo "Step 103. Updating malachite-nz" &&
cargo update &&
echo "Step 104. Formatting malachite-nz" &&
bash ../superfmt.sh &&
echo "Step 105. Running clippy on malachite-nz" &&
cargo clippy --all-targets --features bin_build --features enable_serde &&
echo "Step 106. Running clippy on malachite-nz with 32_bit_limbs" &&
cargo clippy --all-targets --features bin_build --features 32_bit_limbs --features enable_serde &&
echo "Step 107. Running clippy on malachite-nz with no std" &&
cargo clippy --all-targets --features bin_build --features enable_serde --no-default-features &&
echo "Step 108. Running clippy on malachite-nz with 32_bit_limbs and no std" &&
cargo clippy --all-targets --features bin_build --features 32_bit_limbs --features enable_serde --no-default-features &&
echo "Step 109. Testing malachite-nz" &&
cargo test --release --tests --features test_build --features enable_serde &&
echo "Step 110. Testing malachite-nz with no std" &&
cargo test --release --tests --features test_build --features enable_serde --no-default-features &&
echo "Step 111. Testing malachite-nz doctests" &&
bash ../rundoc.sh --features test_build &&
echo "Step 112. Testing malachite-nz with 32_bit_limbs" &&
cargo test --release --tests --features test_build --features 32_bit_limbs --features enable_serde &&
echo "Step 113. Testing malachite-nz with 32_bit_limbs and no std" &&
cargo test --release --tests --features test_build --features 32_bit_limbs --features enable_serde --no-default-features &&
echo "Step 114. Testing malachite-nz doctests with 32_bit_limbs" &&
bash ../rundoc.sh --features test_build --features 32_bit_limbs&&
echo "Step 115. Testing malachite-nz doctests with 32_bit_limbs and random" &&
bash ../rundoc.sh --features test_build --features 32_bit_limbs --features random &&
echo "Step 116. Running extra tests for malachite-nz" &&
python3 extra-tests.py &&
echo "Step 117. Documenting malachite-nz" &&
RUSTDOCFLAGS="--html-in-header katex-header.html" cargo doc --lib --no-deps --features doc-images --features random &&
echo "Step 118. Building malachite-nz lib for wasm with 32_bit_limbs" &&
cargo build --lib --release --features 32_bit_limbs --target wasm32-unknown-unknown &&
echo "Step 119. Building malachite-nz lib for wasm" &&
cargo build --lib --release --target wasm32-unknown-unknown &&
cd ../malachite-q &&
echo "Step 120. Updating malachite-q" &&
cargo update &&
echo "Step 121. Formatting malachite-q" &&
bash ../superfmt.sh &&
echo "Step 122. Running clippy on malachite-q" &&
cargo clippy --all-targets --features bin_build --features enable_serde &&
echo "Step 123. Running clippy on malachite-q with 32_bit_limbs" &&
cargo clippy --all-targets --features bin_build --features enable_serde --features 32_bit_limbs &&
echo "Step 124. Running clippy on malachite-q with no std" &&
cargo clippy --all-targets --features bin_build --features enable_serde --no-default-features &&
echo "Step 125. Running clippy on malachite-q with 32_bit_limbs and no std" &&
cargo clippy --all-targets --features bin_build --features enable_serde --features 32_bit_limbs --no-default-features &&
echo "Step 126. Testing malachite-q" &&
cargo test --release --tests --features bin_build --features enable_serde &&
echo "Step 127. Testing malachite-q with no std" &&
cargo test --release --tests --features bin_build --features enable_serde --no-default-features &&
echo "Step 128. Testing malachite-q doctests" &&
bash ../rundoc.sh --features test_build &&
echo "Step 129. Testing malachite-q with 32_bit_limbs" &&
cargo test --release --tests --features bin_build --features enable_serde --features 32_bit_limbs &&
echo "Step 130. Testing malachite-q with 32_bit_limbs and no std" &&
cargo test --release --tests --features bin_build --features enable_serde --features 32_bit_limbs --no-default-features &&
echo "Step 131. Testing malachite-q doctests with 32_bit_limbs" &&
bash ../rundoc.sh --features test_build --features 32_bit_limbs &&
echo "Step 132. Testing malachite-q doctests with random" &&
bash ../rundoc.sh --features test_build --features random &&
echo "Step 133. Testing malachite-q doctests with random and 32_bit_limbs" &&
bash ../rundoc.sh --features test_build --features random --features 32_bit_limbs &&
echo "Step 134. Documenting malachite-q" &&
RUSTDOCFLAGS="--html-in-header katex-header.html" cargo doc --lib --no-deps --features random &&
echo "Step 135. Building malachite-q lib for wasm" &&
cargo build --lib --release --target wasm32-unknown-unknown &&
echo "Step 136. Building malachite-q lib for wasm with 32_bit_limbs" &&
cargo build --lib --release --features 32_bit_limbs --target wasm32-unknown-unknown &&
cd ../malachite-float &&
echo "Step 137. Updating malachite-float" &&
cargo update &&
echo "Step 138. Formatting malachite-float" &&
bash ../superfmt.sh &&
echo "Step 139. Running clippy on malachite-float" &&
cargo clippy --all-targets --features bin_build --features enable_serde &&
echo "Step 140. Running clippy on malachite-float with 32_bit_limbs" &&
cargo clippy --all-targets --features bin_build --features enable_serde --features 32_bit_limbs &&
echo "Step 141. Running clippy on malachite-float with no std" &&
cargo clippy --all-targets --features bin_build --features enable_serde --no-default-features &&
echo "Step 142. Running clippy on malachite-float with 32_bit_limbs and no std" &&
cargo clippy --all-targets --features bin_build --features enable_serde --features 32_bit_limbs --no-default-features &&
echo "Step 143. Testing malachite-float" &&
cargo test --release --tests --features bin_build --features enable_serde &&
echo "Step 144. Testing malachite-float with no std" &&
cargo test --release --tests --features bin_build --features enable_serde --no-default-features &&
echo "Step 145. Testing malachite-float doctests" &&
bash ../rundoc.sh --features test_build &&
echo "Step 146. Testing malachite-float with 32_bit_limbs" &&
cargo test --release --tests --features bin_build --features 32_bit_limbs &&
echo "Step 147. Testing malachite-float with 32_bit_limbs and no std" &&
cargo test --release --tests --features bin_build --features 32_bit_limbs --no-default-features &&
echo "Step 148. Testing malachite-float doctests with 32_bit_limbs" &&
bash ../rundoc.sh --features test_build --features 32_bit_limbs &&
echo "Step 149. Testing malachite-float doctests with random" &&
bash ../rundoc.sh --features test_build --features random &&
echo "Step 150. Testing malachite-float doctests with random and 32_bit_limbs" &&
bash ../rundoc.sh --features test_build --features random --features 32_bit_limbs &&
echo "Step 151. Documenting malachite-float" &&
RUSTDOCFLAGS="--html-in-header katex-header.html" cargo doc --lib --no-deps --features random &&
echo "Step 152. Building malachite-float lib for wasm" &&
cargo build --lib --release --target wasm32-unknown-unknown &&
echo "Step 153. Building malachite-float lib for wasm with 32_bit_limbs" &&
cargo build --lib --release --features 32_bit_limbs --target wasm32-unknown-unknown &&
cd ../malachite-bigint &&
echo "Step 154. Updating malachite-bigint" &&
cargo update &&
echo "Step 155. Formatting malachite-bigint" &&
bash ../superfmt.sh &&
echo "Step 156. Running clippy on malachite-bigint" &&
cargo clippy --all-targets &&
echo "Step 157. Running clippy on malachite-bigint with no std" &&
cargo clippy --all-targets --no-default-features &&
echo "Step 158. Testing malachite-bigint" &&
cargo test --release &&
echo "Step 159. Testing malachite-bigint with no std" &&
cargo test --release --no-default-features &&
echo "Step 160. Documenting malachite-bigint" &&
cargo doc --lib --no-deps &&
echo "Step 161. Building malachite-bigint lib for wasm" &&
cargo build --lib --release --target wasm32-unknown-unknown &&
cd ../malachite &&
echo "Step 162. Documenting malachite" &&
RUSTDOCFLAGS="--html-in-header katex-header.html" cargo doc --lib --no-deps --features random &&
cd ../malachite-criterion-bench &&
echo "Step 163. Updating malachite-criterion-bench" &&
cargo update &&
echo "Step 164. Formatting malachite-criterion-bench" &&
bash ../superfmt.sh &&
cd .. &&
echo "Step 165. Running additional-lints" &&
python3 additional-lints.py &&
echo "Step 166. Testing against FLINT" &&
cd ../malachite-cpp-test/malachite-test-cpp &&
cargo run --release &&
echo "Step 167. Checking links" &&
cd ../../check-malachite-links &&
cargo run --release
================================================
FILE: docs/CNAME
================================================
www.malachite.rs
================================================
FILE: docs/_config.yml
================================================
theme: jekyll-theme-slate
================================================
FILE: docs/_includes/head-custom.html
================================================
<link rel="shortcut icon" type="image/x-icon" href="{{ "/assets/favicon.ico" | absolute_url }}">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.15.6/dist/katex.min.css" integrity="sha384-ZPe7yZ91iWxYumsBEOn7ieg8q/o+qh/hQpSaPow8T6BwALcXSCS6C6fSRPIAnTQs" crossorigin="anonymous">
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.15.6/dist/katex.min.js" integrity="sha384-ljao5I1l+8KYFXG7LNEA7DyaFvuvSCmedUf6Y6JI7LJqiu8q5dEivP2nDdFH31V4" crossorigin="anonymous"></script>
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.15.6/dist/contrib/auto-render.min.js" integrity="sha384-+XBljXPPiv+OzfbB3cVmLHf4hdUFHlWNZN5spNQ7rmHTXpd7WvJum6fIACpNNfIR" crossorigin="anonymous"
onload="renderMathInElement(document.body);"></script>
================================================
FILE: docs/_layouts/post.html
================================================
---
layout: default
theme: jekyll-theme-slate
---
<h1>{{ page.title }}</h1>
<p><b>{{ page.date | date_to_string }}</b> — {{ page.author }}</p>
{{ content }}
<hr>
Copyright © 2026 Mikhail Hogrefe
================================================
FILE: docs/_posts/2022-06-05-1-intro.md
================================================
---
layout: post
title: Intro
author: Mikhail Hogrefe
---
Welcome to the Malachite blog!
After 5 years and over 600,000 lines of code, I'm finally releasing Malachite, a high-performance
arbitrary-precison arithmetic library for Rust. There's a lot of stuff in this library, and while
it's well-documented on docs.rs, I think it's a good idea to publish some long-form explanations of
what it can do and what the ideas behind it are.
================================================
FILE: docs/_posts/2022-06-05-2-exhaustive.md
================================================
---
layout: post
title: Iterators that generate everything, part 1
author: Mikhail Hogrefe
---
## Iterators
If you've ever used a modern programming language, you're probably familiar with iterators. For example,
if you've got a `Vec<u64>` called `xs` in Rust, you can write this:
```rust
for x in &xs {
println!("{}", x);
}
```
This code takes `xs` and produces an iterator, a thing that knows how to spit out elements. Iterators
are very flexible: you can filter them, map them, zip them, and collect them into concrete
collections like `Vec`s or sets. In Haskell, the basic aggregate type, `List`, _is_ an iterator.
Iterators are also very general. An iterator doesn't have to be backed by anything in memory. You can
easily write this:
```rust
for x: u16 in 0..10 {
println!("{}", x);
}
```
or even
```rust
for x: u16 in 0.. {
println!("{}", x);
}
```
There's something compelling about an iterator that generates EVERY `u16`. If you were testing a
function that takes a `u16`, you could test it on every possible input! If we were dealing with
with `u64`s instead, you'd want to cut it off after some number of values using `take`.
# Some simple examples
The `malachite_base` crate provides lots of exhaustive iterators. Let me show you:
```rust
for b in exhaustive_bools() {
println!("{}", b);
}
```
```
false
true
```
I mentioned `0..` earlier. Malachite provides an iterator that does the same thing but more
explicitly:
```rust
for u in exhaustive_unsigneds::<u16>().take(10) {
println!("{}", u);
}
```
```
0
1
2
3
4
5
6
7
8
9
```
Ok, this isn't very interesting so far. How about signed integers?
```rust
for u in exhaustive_signeds::<i16>().take(10) {
println!("{}", u);
}
```
```
0
1
-1
2
-2
3
-3
4
-4
5
```
The philosophy behind exhaustive iterators in Malachite is that simpler values should come first.
That's why the `i16`s are sorted by absolute value rather than by their usual order. If you _do_ want
to start at -65536 and go up from there, you can use
`primitive_int_increasing_inclusive_range(i16::MIN, i16::MAX)` instead.
By the way, there are lots of other iterators I'm skipping over, like `exhaustive_nonzero_integers`. You can find them by going
[here](https://docs.rs/malachite-base/latest/malachite_base/all.html) and Ctrl-F'ing "exhaustive".
How about `char`s?
```rust
for c in exhaustive_chars().take(10) {
println!("{}", c);
}
```
```
a
b
c
d
e
f
g
h
i
j
```
Again, these are not in their usual order. Thanks to various historical circumstances, the `char`s
that are usually ordered first are mostly unprintable useless characters like "vertical tab" and
"unit separator". `exhaustive_chars` pushes these to the back of the line; see its
[documentation](https://docs.rs/malachite-base/latest/malachite_base/chars/exhaustive/fn.exhaustive_chars.html)
for details.
## Combining iterators
We've touched on most of Rust's primitive types, except for floats; those are more
complicated and I'll discuss them later. But now, let's see how to create iterators for
composite types, like `Option<i32>`:
```rust
for ox in exhaustive_options(exhaustive_signeds::<i32>()).take(10) {
println!("{:?}", ox);
}
```
```
None
Some(0)
Some(1)
Some(-1)
Some(2)
Some(-2)
Some(3)
Some(-3)
Some(4)
Some(-4)
```
Reasonable.
Next, I want to talk about `Union`s. These don't exist in the standard library, so I've defined them in
Malachite. (Since variadic generics aren't a thing in Rust yet, what I've _actually_
defined are `Union2`s and a macro to define unions of higher arity.)
A union (specifically a tagged union, also called a variant or a sum type) is essentially a generic enum. For
example, a value of type `Union2<u16, char>` might be `Union2::A(12)` or `Union2::B('d')`.
It's usually better to use a purpose-built enum than a union, but it's very handy to have
exhaustive iterators for unions. If you want to create an exhaustive iterator for a 2-variant enum,
you can just do `exhaustive_union2s(...).map(|u| match u { ... })`.
Actually, before `exhaustive_union2s`, let me show you `lex_union2s`:
```rust
for b_or_u in lex_union2s(exhaustive_bools(), 1..=3) {
println!("{}", b_or_u);
}
```
```
A(false)
A(true)
B(1)
B(2)
B(3)
```
It's very simple; it just produces all the values of the first variant, then all the values of
the second variant. I've called it `lex` because it returns its elements in lexicographic, or
"dictionary", order (with respect to the order of the input iterators' elements). It's only
suitable when the first iterator is short. You don't want to use
`lex_union2s(exhaustive_unsigneds::<u64>(), ...)` because you'll be waiting forever
before you see the second variant. In general, `exhaustive_union2s` is the better choice:
```rust
for u_or_b in exhaustive_union2s(
exhaustive_unsigneds::<u64>(),
exhaustive_bools()
).take(10) {
println!("{}", u_or_b);
}
```
```
A(0),
B(false),
A(1),
B(true),
A(2),
A(3),
A(4),
A(5),
A(6),
A(7),
```
and now the `B` variant gets to see the light of day. `exhaustive_union3s`, etc., work in the same
way, selecting between their variants in a round-robin fashion.
# Intermission
We haven't gotten to the really interesting bits, which have to do with generating
tuples (and after that, lists, sets, and floats). I'll talk about those in future posts.
[Part 2: Generating tuples](/2022/07/03/exhaustive)
================================================
FILE: docs/_posts/2022-07-03-exhaustive.md
================================================
---
layout: post
title: Iterators that generate everything, part 2
author: Mikhail Hogrefe
---
## Introduction
In [Part 1](/2022/06/05/2-exhaustive) of this series, I described how Malachite provides iterators that generate all values of a type, or all values satisfying some condition. Now I'm going to show you how to generate tuples.
It's not immediately obvious how to do this. One thing you might try is generating the tuples in lexicographic order. Malachite lets you do this:
```rust
for p in lex_pairs_from_single(exhaustive_unsigneds::<u64>()).take(10) {
println!("{}", p);
}
```
```
(0, 0)
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(0, 5)
(0, 6)
(0, 7)
(0, 8)
(0, 9)
```
(The "from_single" in [`lex_pairs_from_single`](https://docs.rs/malachite-base/latest/malachite_base/tuples/exhaustive/fn.lex_pairs_from_single.html) indicates that both elements of the output pairs come from the same iterator. There's also a [`lex_pairs`](https://docs.rs/malachite-base/latest/malachite_base/tuples/exhaustive/fn.lex_pairs.html) function that accepts two iterators.)
As you can see, lexicographic generation only makes sense if the input iterator has a small number of elements, like `exhaustive_bools`. It doesn't work so well for `exhaustive_unsigneds::<u64>`, since you'd have to wait forever to get to any pair that doesn't start with 0. But Malachite does provide [`exhaustive_pairs`](https://docs.rs/malachite-base/latest/malachite_base/tuples/exhaustive/fn.exhaustive_pairs.html) and [`exhaustive_pairs_from_single`](https://docs.rs/malachite-base/latest/malachite_base/tuples/exhaustive/fn.exhaustive_pairs_from_single.html), that work well for any input iterators. How do these functions work?
## First attempt: the Cantor pairing function
For simplicity, let's first consider `exhaustive_pairs_from_single(exhaustive_naturals())`. To think about generating every pair of `Natural`s, it helps to visualize a path through an infinite grid. One such path is this:
<p align="center">
<img width="300" src="/assets/exhaustive-part-2/cantor-grid.svg" alt="The path defined by the Cantor pairing function">
</p>
You can think of it as first generating (0, 0), whose sum is 0; then (1, 0) and (0, 1), whose sum is 1; then (2, 0), (1, 1), and (0, 2), whose sum is 2; and so on. This path describes a bijection between the indices 0, 1, 2, ..., and all pairs of natural numbers. The opposite direction of this bijection, that takes pairs to indices, is known as the Cantor pairing function.
This bijection has some nice properties; for example, the function from pairs to indices is a polynomial in the elements of the pair: the pair $$(x, y)$$ corresponds to index $$\tfrac{1}{2}(x + y)(x + y + 1)$$. We can also look at the two functions from sequence index to the first and second elements of the pairs. These functions look like this:
<p align="center">
<img width="650" src="/assets/exhaustive-part-2/cantor-graph.svg" alt="The inverses of the Cantor pairing function">
</p>
Although the functions jump around a lot (they have to, since they must evaluate to every natural number infinitely many times), there's a sense in which they are nicely balanced. Both are $$O(\sqrt n)$$, and if you take evaluate them at a random large input, they're generally about the same size:
<p align="center">
<img height="150" src="/assets/exhaustive-part-2/cantor-large.svg" alt="The Cantor unpairing of powers of 3">
</p>
However, it isn't obvious how generalize the Cantor pairing function to triples in a balanced way. The standard way to create a tripling function from a pairing function is $$g(x, y, z) = f(x, f(y, z))$$, but this is no longer balanced. If $$f$$ is the Cantor pairing function, then the three outputs of $$g^{-1}$$ are $$O(\sqrt n)$$, $$O(\sqrt[4] n)$$, and $$O(\sqrt[4]n)$$. Here's what the corresponding table looks like:
<p align="center">
<img height="150" src="/assets/exhaustive-part-2/cantor-triples-large.svg" alt="An unbalanced Cantor untripling of powers of 3">
</p>
## More balance and flexibility with bit interleaving
Instead of the Cantor pairing function, Malachite uses bit interleaving. This idea is not new; it has been described by [Steven Pigeon](https://hbfs.wordpress.com/2011/09/27/pairing-functions/) and others.
To generate the pairs corresponding to index 0, 1, 2, and so on, first write the indices in binary, with infinitely many leading zeros:
<p align="center">
<img height="200" src="/assets/exhaustive-part-2/interleave-bits-1.svg" alt="First step in un-interleaving bits">
</p>
And then distribute the bits of each index into the two slots of the corresponding pair. The even-indexed bits (counting from the right) end up in the second slot, and the odd-indexed bits in the first:
<p align="center">
<img height="200" src="/assets/exhaustive-part-2/interleave-bits-2.svg" alt="Final steps in un-interleaving bits">
</p>
I've color-coded the bits according to which slot they end up in. Malachite keeps track of this using an explicit bit map that looks like $$[1, 0, 1, 0, 1, 0, \ldots]$$, indicating that bit 0 goes to slot 1, bit 1 goes to slot 0, bit 2 goes to slot 1, and so on.
This is how this method walks through the grid of pairs of natural numbers:
<p align="center">
<img width="400" src="/assets/exhaustive-part-2/interleave-grid.svg" alt="The path defined by the bit-interleaving pairing function">
</p>
This path is called a [Z-order curve](https://en.wikipedia.org/wiki/Z-order_curve), although with this choice of coordinates it looks like it's made up of N's rather than Z's.
And here's what the functions from the index to the first and second elements of the pairs look like:
<p align="center">
<img width="650" src="/assets/exhaustive-part-2/interleave-pairs-graph.svg" alt="The inverses of the bit interleaving pairing function">
</p>
Like the inverses of the Cantor pairing function, these functions are balanced in the sense that both are $$O(\sqrt n)$$, although here the first element lags noticeably behind the second. And here's a table showing them evaluated at large indices:
<p align="center">
<img height="150" src="/assets/exhaustive-part-2/interleave-large.svg" alt="Bit un-interleaving of powers of 3">
</p>
The advantage that this approach has over the Cantor pairing approach is flexibility. We can generate triples in a balanced way simply by changing the bit map to $$[2, 1, 0, 2, 1, 0, 2, 1, 0, \ldots]$$:
<p align="center">
<img height="400" src="/assets/exhaustive-part-2/interleave-triples-bits.svg" alt="un-interleaving bits to form triples">
</p>
Here are the three functions from index to output. They each are $$O(\sqrt[3]n)$$.
<p align="center">
<img width="650" src="/assets/exhaustive-part-2/interleave-triples-graph.svg" alt="The inverses of the bit interleaving tripling function">
</p>
Here they are evaluated at large indices:
<p align="center">
<img height="150" src="/assets/exhaustive-part-2/interleave-triples-large.svg" alt="Bit un-interleaving of powers of 3 to form triples">
</p>
This generalizes straightforwardly to $$k$$-tuples for any $$k$$. Notice that the first $$2^{ka}$$ tuples are all the tuples with elements less than $$2^a$$.
## Customized balancing
By changing the bit map further, we can deliberately unbalance the tuples. For example, if we want to produce pairs where the second element of the pair is $$O(\sqrt[3]n)$$ and the first element is $$O(n^{2/3})$$, we can use the bit map $$[1, 0, 0, 1, 0, 0, 1, 0, 0, \ldots]$$. If we want the the first element to be exponentially larger than the second, we can use $$[0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, \ldots]$$, where there is a 1 at the $$2^i$$th position and 0 elsewhere.
To actually generate the pair sequences in the two preceding examples, you can use
```rust
exhaustive_pairs_custom_output(
exhaustive_naturals(),
exhaustive_naturals(),
BitDistributorOutputType::normal(2),
BitDistributorOutputType::normal(1),
)
```
and
```rust
exhaustive_pairs_custom_output(
exhaustive_naturals(),
exhaustive_naturals(),
BitDistributorOutputType::normal(1),
BitDistributorOutputType::tiny(),
)
```
respectively. See the documentation of [exhaustive_pairs_custom_output](https://docs.rs/malachite-base/0.2.4/malachite_base/tuples/exhaustive/fn.exhaustive_pairs_custom_output.html) and [BitDistributorOutputType](https://docs.rs/malachite-base/latest/malachite_base/iterators/bit_distributor/struct.BitDistributorOutputType.html) for more details.
## Generating tuples of other iterators
So far I've only talked about generating tuples of `Natural`s. What about tuples of elements from some other iterator `xs`? If `xs` is infinitely long, then the process is straightforward. Instead of generating, say, (8, 3), generate the pair consisting of the 8th and 3rd elements of `xs` (indexing from 0, of course). Internally, Malachite uses a structure called [`IteratorCache`](https://docs.rs/malachite-base/latest/malachite_base/iterators/iterator_cache/struct.IteratorCache.html), which stores the values produced by `xs` into a `Vec` for easy access.
For example, here's how to generate all pairs of the characters `'a'` to `'z'` (in this case, there are additional complications due to `xs` being finite, but we'll address those in a moment):
```rust
for p in exhaustive_pairs_from_single('a'..='z').take(10) {
println!("{:?}", p);
}
```
```
(a, a)
(a, b)
(b, a)
(b, b)
(a, c)
(a, d)
(b, c)
(b, d)
(c, a)
(c, b)
```
## Dealing with finite iterators
Finite iterators are a bit of a problem. You can't generate the (8th, 3rd) pair if the input iterator has no 8th element. To take an extreme case, consider `exhaustive_pairs(exhaustive_naturals(), exhaustive_bools())`. There are only two bools, so any index pair $$(i, j)$$ where $$j \geq 2$$ can't be used for indexing. Here's our grid of indices again, with valid indices green and invalid indices red:
<p align="center">
<img width="400" src="/assets/exhaustive-part-2/interleave-grid-filtered.svg" alt="Valid indices when one iterator has length 2">
</p>
My original solution was just to skip over the invalid indices, with a bit of extra logic to determine when both input iterators are finished. This was very slow: out of the first $$n$$ pairs, only about $$2 \sqrt n$$ are valid, and the situation gets worse for higher-arity tuples. So what does `exhaustive_pairs` do instead?
Again, we can leverage the bit map! This scenario is actually what led me to make the bit map an explicit object in memory. What `exhaustive_pairs` does is notice when one of its iterators has completed, and then adjusts the bit map on the fly. In this particular case, it realizes that since `exhaustive_bools` produces two elements, it only needs a single bit for indexing; and then bit map is modified from $$[1, 0, 1, 0, 1, 0, 1, 0, \ldots]$$, to $$[1, 0, 0, 0, 0, 0, 0, \ldots]$$. In general, modifying the bit map on the fly is dangerous because you might end up repeating some output that you've already produced, but `exhaustive_pairs` only modifies the part of the map that hasn't been used yet.
If the finite iterator's length is a power of 2, as it was in this example, then updating the bit map results in all indices being valid. If it isn't a power of 2, then some indices will remain invalid; for example, in `exhaustive_pairs(exhaustive_naturals(), 0..6)` the bit map will be updated from $$[1, 0, 1, 0, 1, 0, 1, 0, \ldots]$$, to $$[1, 0, 1, 0, 1, 0, 0, 0, \ldots]$$, so that the index of the second pair slot will vary from 0 to 7, and only $$3/4$$ of all the indices will be valid. But this is a constant proportion; it's much better than the earlier example where only $$(2 \sqrt n)/n$$ were valid.
(In this particular case, the best thing to do would be to use `lex_pairs(exhaustive_naturals(), exhaustive_bools())`, which would produce (0, false), (0, true), (1, false), (1, true), and so on. But in general, when you call `exhaustive_pairs(xs, ys)` you might not know ahead of time whether `ys` is short, long, or infinite.)
In the next part, I will discuss how Malachite generates all `Vec`s containing elements from some iterator.
================================================
FILE: docs/_posts/2022-07-30-denominators.md
================================================
---
layout: post
title: Which denominators does an interval contain?
author: Mikhail Hogrefe
---
## Introduction
In this post I'm going to talk a bit about a problem that came up when I was figuring out how to generate rational numbers exhaustively. Malachite generates all positive rationals using the [Calkin-Wilf sequence](https://en.wikipedia.org/wiki/Calkin%E2%80%93Wilf_tree#Breadth_first_traversal):
1, 1/2, 2, 1/3, 3/2, 2/3, 3, 1/4, 4/3, 3/5, 5/2, 2/5, 5/3, 3/4, 4, 1/5, 5/4, 4/7, 7/3, 3/8, ...,
and by manipulating this sequence a bit it can also generate all rationals, all negative rationals, and so on. How about generating all rationals in a specified interval? This has many uses: for example, when testing conversion from rationals to floats, we might want to generate rationals that fall into the 64-bit subnormal float range.
For the remainder of this post I'm going to consider closed intervals only.
## First try
The most straightforward approach is this:
1. Generate all rationals in $$[0, 1]$$.
2. Scale those rationals to bring them into the target interval.
Step 1 is easy: we can generate 0 and 1, and then select every other rational from the above sequence:
0, 1, 1/2, 1/3, 2/3, 1/4, 3/5, 2/5, 3/4, 1/5, 4/7, 3/8, 5/7, 2/7, 5/8, 3/7, 4/5, 1/6, 5/9, 4/11, ... .
Step 2 is also easy. If our target interval is $$[a, b]$$, we transform each rational using $$x \to (b - a)x + a$$. For example, here are the rationals in $$[1/3, 1/2]$$:
1/3, 1/2, 5/12, 7/18, 4/9, 3/8, 13/30, 2/5, 11/24, 11/30, 3/7, 19/48, 19/42, 8/21, 7/16, 17/42, 7/15, 13/36, 23/54, 13/33, ... .
For a simple interval this approach works fine. But what if we generate intervals in $$[268876667/98914198, 245850922/78256779]$$? The endpoints of this interval are the simplest rationals that round to the best 64-bit float representations of $$e$$ and $$\pi$$, respectively. Our algorithm gives us
268876667/98914198, 245850922/78256779, 45359568684866149/15481413065696484, 33200495296270871/11611059799272363, 69677715462056705/23222119598544726, 87442412500217335/30962826131392968, 19172880691153809/6450588777373535, 111760559277407891/38703532664241210, 31331954079749087/10320942043797656, 54241917203946464/19351766332120605, ... .
This is not so nice. Our interval contains nice rationals like 3, 11/4, 14/5, and 17/6, but they are nowhere to be seen (they will appear eventually, but much later in the sequence). We want an algorithm that gives preferential treatment to rationals with small denominators. Here's what Malachite does:
An improved algorithm
---------------------
Malachite's algorithm needs to be able to do three things:
1. Determine which denominators occur in an interval;
2. Generate all rationals with a given denominator in an interval;
3. Given infinitely many iterators, each generating rationals with different denominators, interleave the iterators into a single iterator.
Number 2 is easy to do and not very interesting. You can see the details [here](https://docs.rs/malachite-q/latest/malachite_q/exhaustive/fn.exhaustive_rationals_with_denominator_inclusive_range.html). Number 3 is more interesting, but already solved. I'll post about it in the future, but for now I'll just leave a link to the relevant function [here](https://docs.rs/malachite-base/latest/malachite_base/tuples/exhaustive/fn.exhaustive_dependent_pairs.html). That leaves number 1.
## Finding all denominators in an interval
Let's define the problem more explicitly.
**Problem:** Given a closed interval $$[a, b]$$ with $$a, b \in \mathbb{Q}$$ and $$a < b$$, for which $$d \in \N^+$$ does there exist an $$n \in \Z$$ with $$\gcd(n, d) = 1$$ and $$n/d \in [a, b]$$?
The simplest algorithm is to consider each denominator 1, 2, 3, ... in turn and determine whether some rational with the denominator exists in the interval. This works fine unless the diameter $$b - a$$ is very small. If the interval is $$[0, 2^{-100}]$$, it would take a very long time to find an admissible denominator greater than 1.
Luckily, Malachite knows how to find the simplest rational in an interval ("simplest" meaning "having the lowest denominator"). It uses the continued fractions of the endpoints and follows the algorithm sketched out [here](https://en.wikipedia.org/wiki/Continued_fraction#Best_rational_approximations). This gives us the lowest denominator in the interval in $$O(n^2 \log n \log\log n)$$ time, $$n$$ being the maximum bit-length of the numerators and denominators of both endpoints. Once we've found the lowest denominator, we can find the $$m$$ rationals with that denominator in $$[a, b]$$ and then partition $$[a, b]$$ into $$m + 1$$ smaller intervals. Then we can repeat the process to get the second-lowest denominator, and so on.
This algorithm is efficient enough to be useful, but it's still a bit cumbersome. Our intuition suggests that $$[a, b]$$ contains every denominator in $$\N^+$$ except for finitely many exceptions: in other words, that for every interval $$[a, b]$$ there exists a threshold $$D$$ such that for all $$d \geq D$$, $$[a, b]$$ contains a rational with denominator $$d$$. If we knew what $$D$$ was, then we could find start finding denominators using our cumbersome continued-fraction method, but once we reached $$D$$ we could simply generate $$D, D + 1, D + 2, \ldots$$ forever.
For the remainder of this post, I'll prove that a $$D$$ exists for any interval and give an efficient algorithm for finding it (though it generally won't be the lowest possible $$D$$).
## The relationship between an interval's diameter and the denominators it contains
Let $$s = b - a$$ be the diameter of $$[a, b]$$. If $$s \geq 1$$, then we can take $$D = 1$$: $$[a, b]$$ contains all denominators in $$\N^+$$. (For any denominator $$d$$, $$k + 1/d$$ is in $$[a, b]$$ for some integer $$k$$.)
What if $$s < 1$$? We might think that if $$s \geq 1/d$$ then $$[a, b]$$ must contain some rational with denominator $$d$$, but this is not the case. For example, an interval with $$s > 1/6$$ might not contain any sixths:
<p align="center">
<img width="500" src="/assets/denominators/sixths.svg" alt="The largest gap between sixths">
</p>
The largest gap between sixths is $$2/3$$. Let's define $$f(d)$$ to be the largest gap between fractions with denominator $$d$$:
<p align="center">
<img width="600" src="/assets/denominators/gaps.svg" alt="The largest gap between rationals with denominators 1 through 10">
</p>
<p align="center">
<img width="600" src="/assets/denominators/gap-graph.svg" alt="A graph of the largest-gap function">
</p>
Any interval with $$s \geq f(d)$$ is, by definition, guaranteed to contain some rational with denominator $$d$$. If $$f$$ were monotonically decreasing, then we could use that to prove that $$D$$ exists. We'd simply need to find a $$D$$ such that $$f(D) \leq s$$, and then any $$f(d)$$ for $$d \geq D$$ would also be less than or equal to $$s$$. But $$f$$ does not monotonically decrease.
## The Jacobsthal function and primorials
I couldn't find any reference to $$f(n)$$ in the literature, but fortunately $$g(n) = n f(n)$$ has been studied: it's called the [Jacobsthal function](http://oeis.org/A048669) (not to be confused with the Jacobsthal numbers, which are something unrelated). $$g(n)$$ is the size of the maximal gap in the list of all integers relatively prime to $$n$$.
<p align="center">
<img width="600" src="/assets/denominators/j-graph.svg" alt="A graph of the Jacobsthal function">
</p>
We can make use of the bound ([^1]) $$g(n) \leq 2^w$$, where $$w$$ is the number of distinct prime factors of $$n$$.
| constraint on $$n$$ | bound on $$w$$ | bound on $$g$$ | bound on $$f$$ |
|-----------------------|----------------|------------------|----------------------|
| $$1 \leq n < 2$$ | $$w \leq 0$$ | $$g(n) \leq 1$$ | $$f(n) \leq 1$$ |
| $$2 \leq n < 6$$ | $$w \leq 1$$ | $$g(n) \leq 2$$ | $$f(n) \leq 1$$ |
| $$6 \leq n < 30$$ | $$w \leq 2$$ | $$g(n) \leq 4$$ | $$f(n) \leq 2/3$$ |
| $$30 \leq n < 210$$ | $$w \leq 3$$ | $$g(n) \leq 8$$ | $$f(n) \leq 4/15$$ |
| $$210 \leq n < 2310$$ | $$w \leq 4$$ | $$g(n) \leq 16$$ | $$f(n) \leq 8/105$$ |
| $$\ldots$$ | $$\ldots$$ | $$\ldots$$ | $$\ldots$$ |
The sequence in the leftmost column, 1, 2, 6, 30, 210, ..., is the sequence of [primorials](https://en.wikipedia.org/wiki/Primorial): they are the products of the first 0, 1, 2, ... primes and therefore the smallest integers with 0, 1, 2, ... distinct prime factors. The $$n$$th primorial is denoted $$p_n\#$$. The sequence of bounds in the rightmost column, 1, 1, 2/3, 4/15, 8/105, ... is $$2^n/p_n\#$$ and is weakly monotonically decreasing. This allows us to construct a weakly monotonically decreasing function $$h$$ that bounds $$f$$ from above:
$$h(n) = 2^k/p_k\# \ \text{where} \ p_k\# \leq n < p_{k+1}\#$$.
Here are $$f$$ and $$h$$ plotted together:
<p align="center">
<img width="600" src="/assets/denominators/gap-and-bound-graph.svg" alt="A graph of the largest-gap function and an upper bound">
</p>
$$h$$ is not a very tight bound. With more careful analysis, we could come up with a better one, perhaps by interpolating between the primorials or by making use of the bound ([^1]) $$g(h) \leq 2k^{2+2e\log k}$$.
We now have an algorithm or determining a threshold $$D$$ for an interval $$[a, b]$$:
1. Find the diameter $$s = b - a$$.
2. Compute the sequence $$2^n/p_n\#$$ until it is less than or equal to $$s$$: the sequence decreases as $$O((2/n)^n)$$, so this step doesn't take long.
3. Let $$n$$ be the value at which $$2^n/p_n\# \leq s$$. Then take $$D$$ to be $$p_n\#$$.
## Results
Let's go back to our example interval, $$[268876667/98914198, 245850922/78256779]$$. Its diameter is about 0.42, so its $$D$$ is 30, meaning that it's guaranteed to contain all denominators greater than or equal to 30. This threshold is low enough that we can just test all the denominators 1 through 29, and after doing this we find that the denominators 1, 4, and all denominators greater than 4 are present.
Malachite generates the rationals contained in the interval in this order:
3, 11/4, 14/5, 20/7, 17/6, 23/8, 25/8, 30/11, 25/9, 29/10, 26/9, 31/11, 28/9, 31/10, 32/11, 41/15, 34/11, 35/12, 37/12, 39/14, ... .
[^1]: Hans-Joachim Kanold, *Über eine zahlentheoretische Funktion von Jacobsthal*, Mathematische Annalen 170.4 (1967): 314-326
================================================
FILE: docs/assets/denominators/gap-and-bound-graph.asy
================================================
import graph;
size(600,400,IgnoreAspect);
int gcd(int a, int b) {
while (b != 0) {
int t = b;
b = a % b;
a = t;
}
return a;
}
int jacobsthal(int n) {
int previous = 0;
int largest_gap = 0;
for (int i = 0; i <= 2 * n; ++i) {
if (gcd(i, n) == 1) {
int gap = i - previous;
if (gap > largest_gap) {
largest_gap = gap;
}
previous = i;
}
}
return largest_gap;
}
scale(Linear,Log);
real[] x={};
real[] y1={};
real[] y2={};
for (int i = 1; i < 500; ++i) {
x.push(i);
y1.push(jacobsthal(i)/i);
if (i < 6) {
y2.push(1);
} else if (i < 30) {
y2.push(2/3);
} else if (i < 210) {
y2.push(4/15);
} else if (i < 2310) {
y2.push(8/105);
}
}
draw(graph(x,y1),black,"$f(n)$");
draw(graph(x,y2),red,"$h(n)$");
xaxis(BottomTop,LeftTicks);
yaxis(LeftRight, RightTicks);
add(legend(),point(NW),(50,-25),UnFill);
================================================
FILE: docs/assets/denominators/gap-graph.asy
================================================
import graph;
size(600,400,IgnoreAspect);
int gcd(int a, int b) {
while (b != 0) {
int t = b;
b = a % b;
a = t;
}
return a;
}
int jacobsthal(int n) {
int previous = 0;
int largest_gap = 0;
for (int i = 0; i <= 2 * n; ++i) {
if (gcd(i, n) == 1) {
int gap = i - previous;
if (gap > largest_gap) {
largest_gap = gap;
}
previous = i;
}
}
return largest_gap;
}
scale(Linear,Log);
real[] x={};
real[] y={};
for (int i = 1; i < 500; ++i) {
x.push(i);
y.push(jacobsthal(i)/i);
}
draw(graph(x,y),black,"$f(n)$");
xaxis(BottomTop,LeftTicks);
yaxis(LeftRight, RightTicks);
add(legend(),point(NW),(25,-25),UnFill);
================================================
FILE: docs/assets/denominators/gaps.asy
================================================
import graph;
size(15cm);
pen small=fontcommand("\scriptsize");
int gcd(int a, int b) {
while (b != 0) {
int t = b;
b = a % b;
a = t;
}
return a;
}
int jacobsthal(int n) {
int previous = 0;
int largest_gap = 0;
for (int i = 0; i <= 2 * n; ++i) {
if (gcd(i, n) == 1) {
int gap = i - previous;
if (gap > largest_gap) {
largest_gap = gap;
}
previous = i;
}
}
return largest_gap;
}
string gap_function(int d) {
int n = jacobsthal(d);
int g = gcd(n, d);
n = n#g;
d = d#g;
if (d == 1) {
return string(n);
} else {
return string(n) + "/" + string(d);
}
}
void draw_rationals(int d, real offset) {
guide gaxis=(0,offset)--(20,offset);
draw(gaxis);
for(int i = 0; i < 3; ++i){
tick(relpoint(gaxis,i/2),-plain.I*reldir(gaxis,i/2),ticksize*2);
}
for(int i = 0; i < 20; ++i){
tick(relpoint(gaxis,i/20),-plain.I*reldir(gaxis,i/20),ticksize);
}
label("$0$",relpoint(gaxis,0),-3*plain.I*reldir(gaxis,0));
label("$1$",relpoint(gaxis,0.5),-3*plain.I*reldir(gaxis,0.5));
label("$2$",relpoint(gaxis,1),-3*plain.I*reldir(gaxis,1));
for (int i= 0; i <= 2 * d; ++i) {
if (gcd(i, d) == 1) {
dot((i*10/d, offset), red);
if (d != 1) {
label("$" + string(i) + "/" + string(d) + "$",relpoint(gaxis,i/(2*d)),-2*plain.I*reldir(gaxis,0.5), red+small);
}
}
}
label("$f(" + string(d) + ") = " + gap_function(d) + "$",(24.5, offset), align=LeftSide);
}
real offset = 0;
for (int d = 1; d <= 10; ++d) {
draw_rationals(d, offset);
offset -= 2;
}
// Force bottom margin to expand
draw(box((-1,1),(-0.5, -20)),white);
================================================
FILE: docs/assets/denominators/j-graph.asy
================================================
import graph;
size(600,400,IgnoreAspect);
int gcd(int a, int b) {
while (b != 0) {
int t = b;
b = a % b;
a = t;
}
return a;
}
int jacobsthal(int n) {
int previous = 0;
int largest_gap = 0;
for (int i = 0; i <= 2 * n; ++i) {
if (gcd(i, n) == 1) {
int gap = i - previous;
if (gap > largest_gap) {
largest_gap = gap;
}
previous = i;
}
}
return largest_gap;
}
//scale(Linear,Log);
real[] x={};
real[] y={};
for (int i = 1; i < 500; ++i) {
x.push(i);
y.push(jacobsthal(i));
}
draw(graph(x,y),black,"$g(n)$");
xaxis(BottomTop,LeftTicks);
yaxis(LeftRight, RightTicks);
add(legend(),point(NW),(25,-25),UnFill);
================================================
FILE: docs/assets/denominators/sixths.asy
================================================
import graph;
size(10cm);
guide gaxis=(0,0)--(20,0);
pen small=fontcommand("\footnotesize");
draw(gaxis);
for(int i = 0; i < 3; ++i){
tick(relpoint(gaxis,i/2),-plain.I*reldir(gaxis,i/2),ticksize*2);
}
for(int i = 0; i < 20; ++i){
tick(relpoint(gaxis,i/20),-plain.I*reldir(gaxis,i/20),ticksize);
}
label("$0$",relpoint(gaxis,0),-3*plain.I*reldir(gaxis,0));
label("$1$",relpoint(gaxis,0.5),-3*plain.I*reldir(gaxis,0.5));
label("$2$",relpoint(gaxis,1),-3*plain.I*reldir(gaxis,1));
int gcd(int a, int b) {
while (b != 0) {
int t = b;
b = a % b;
a = t;
}
return a;
}
for (int i= 0; i <= 12; ++i) {
if (gcd(i, 6) == 1) {
dot((i*10/6, 0), red);
label("$" + string(i) + "/6$",relpoint(gaxis,i/(2*6)),-2*plain.I*reldir(gaxis,0.5), red+small);
}
}
draw((1.8, 0.2)--(1.8, -0.2),blue+linewidth(0.5mm));
draw((1.8, 0)--(8.2, 0),blue+linewidth(0.5mm));
draw((8.2, 0.2)--(8.2, -0.2),blue+linewidth(0.5mm));
================================================
FILE: docs/assets/exhaustive-part-2/cantor-graph.asy
================================================
import graph;
size(600,400,IgnoreAspect);
pair unpair(int i) {
int j = 0;
int r = i;
while (r >= j) {
r -= j;
j += 1;
}
j -= 1;
return (j - r, r);
}
real[] x={};
real[] y1={};
real[] y2={};
for (int i = 0; i < 500; ++i) {
x.push(i);
y1.push(unpair(i).x);
y2.push(unpair(i).y);
}
real[] z=sqrt(2x);
draw(graph(x,y1),red,"first element");
draw(graph(x,y2),blue,"second element");
draw(graph(x,z),black,"$\sqrt{2x}$");
xaxis(BottomTop,LeftTicks);
yaxis(LeftRight, RightTicks);
add(legend(),point(NW),(25,-25),UnFill);
================================================
FILE: docs/assets/exhaustive-part-2/cantor-grid.asy
================================================
unitsize(1cm);
int size = 5;
for (int x = 0; x < size; ++x) {
for (int y = 0; y < size; ++y) {
dot((x, y));
}
}
pair unpair(int i) {
int j = 0;
int r = i;
while (r >= j) {
r -= j;
j += 1;
}
j -= 1;
return (j - r, r);
}
path boundary = box((-0.5, -0.5), (size + 0.5, size + 0.5));
pair previous = (0, 0);
for (int i = 1; i < 15; ++i) {
pair next = unpair(i);
bool previous_in_range = previous.x < size && previous.y < size;
bool next_in_range = next.x < size && next.y < size;
if (previous_in_range && next_in_range) {
draw(previous -- next, arrow=Arrow, gray);
} else {
draw(previous -- next, gray+Dotted());
}
previous = next;
}
clip(boundary);
================================================
FILE: docs/assets/exhaustive-part-2/cantor-large.tex
================================================
\documentclass[11pt]{article}
\usepackage{amsmath}
\begin{document}
\begin{equation*}
\begin{split}
3^{20} &\rightarrow (33123, 50384) \\
3^{40} &\rightarrow (2293673435, 2637384353) \\
3^{60} &\rightarrow (158808187801698, 132365843578904) \\
3^{80} &\rightarrow (12105097562203174223, 5088437816790055004) \\
3^{100} &\rightarrow (416864661676079910029691, 598396408918091282666529) \\
\end{split}
\end{equation*}
\end{document}
================================================
FILE: docs/assets/exhaustive-part-2/cantor-triples-large.tex
================================================
\documentclass[11pt]{article}
\usepackage{amsmath}
\begin{document}
\begin{equation*}
\begin{split}
3^{20} &\rightarrow (33123, 298, 18) \\
3^{40} &\rightarrow (2293673435, 7475, 65152) \\
3^{60} &\rightarrow (158808187801698, 13757728, 2512848) \\
3^{80} &\rightarrow (12105097562203174223, 2695483339, 494638230) \\
3^{100} &\rightarrow (416864661676079910029691, 871747234874, 222233029040) \\
\end{split}
\end{equation*}
\end{document}
================================================
FILE: docs/assets/exhaustive-part-2/interleave-bits-1.tex
================================================
\documentclass[11pt]{article}
\usepackage{amsmath}
\begin{document}
\begin{tabular}{rcr}
0 & $\rightarrow$ & \ldots 000000 \\
1 & $\rightarrow$ & \ldots 000001 \\
2 & $\rightarrow$ & \ldots 000010 \\
3 & $\rightarrow$ & \ldots 000011 \\
4 & $\rightarrow$ & \ldots 000100 \\
5 & $\rightarrow$ & \ldots 000101 \\
6 & $\rightarrow$ & \ldots 000110 \\
7 & $\rightarrow$ & \ldots 000111 \\
\end{tabular}
\end{document}
================================================
FILE: docs/assets/exhaustive-part-2/interleave-bits-2.tex
================================================
\documentclass[11pt]{article}
\usepackage{amsmath}
\usepackage{xcolor}
\begin{document}
\begin{tabular}{rcrcrcr}
0 & $\rightarrow$ & \ldots \color{red}0\color{blue}0\color{red}0\color{blue}0\color{red}0\color{blue}0 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00000 \color{black})$ & $\rightarrow$ & $(0, 0)$ \\
1 & $\rightarrow$ & \ldots \color{red}0\color{blue}0\color{red}0\color{blue}0\color{red}0\color{blue}1 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00001 \color{black})$ & $\rightarrow$ & $(0, 1)$ \\
2 & $\rightarrow$ & \ldots \color{red}0\color{blue}0\color{red}0\color{blue}0\color{red}1\color{blue}0 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00000 \color{black})$ & $\rightarrow$ & $(1, 0)$ \\
3 & $\rightarrow$ & \ldots \color{red}0\color{blue}0\color{red}0\color{blue}0\color{red}1\color{blue}1 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00001 \color{black})$ & $\rightarrow$ & $(1, 1)$ \\
4 & $\rightarrow$ & \ldots \color{red}0\color{blue}0\color{red}0\color{blue}1\color{red}0\color{blue}0 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00010 \color{black})$ & $\rightarrow$ & $(0, 2)$ \\
5 & $\rightarrow$ & \ldots \color{red}0\color{blue}0\color{red}0\color{blue}1\color{red}0\color{blue}1 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00011 \color{black})$ & $\rightarrow$ & $(0, 3)$ \\
6 & $\rightarrow$ & \ldots \color{red}0\color{blue}0\color{red}0\color{blue}1\color{red}1\color{blue}0 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00010 \color{black})$ & $\rightarrow$ & $(1, 2)$ \\
7 & $\rightarrow$ & \ldots \color{red}0\color{blue}0\color{red}0\color{blue}1\color{red}1\color{blue}1 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00011 \color{black})$ & $\rightarrow$ & $(1, 3)$ \\
\end{tabular}
\end{document}
================================================
FILE: docs/assets/exhaustive-part-2/interleave-grid-filtered.asy
================================================
unitsize(1cm);
int size = 8;
for (int x = 0; x < size; ++x) {
for (int y = 0; y < size; ++y) {
if (y < 2) {
dot((x, y), green);
} else {
dot((x, y), red);
}
}
}
pair unpair(int i) {
int x = 0;
int y = 0;
bool on_x = false;
int out_mask = 1;
while (i != 0) {
if (i % 2 != 0) {
if (on_x) {
x += out_mask;
} else {
y += out_mask;
}
}
if (on_x) {
on_x = false;
out_mask *= 2;
} else {
on_x = true;
}
i #= 2;
}
return (x, y);
}
path boundary = box((-0.5, -0.5), (size + 0.5, size + 0.5));
pair previous = (0, 0);
for (int i = 1; i < size * size; ++i) {
pair next = unpair(i);
bool previous_in_range = previous.x <= size && previous.y <= size;
bool next_in_range = next.x <= size && next.y <= size;
if (previous_in_range && next_in_range) {
draw(previous -- next, arrow=Arrow, gray);
} else {
draw(previous -- next, gray+Dotted());
}
previous = next;
}
clip(boundary);
================================================
FILE: docs/assets/exhaustive-part-2/interleave-grid.asy
================================================
unitsize(1cm);
int size = 8;
for (int x = 0; x < size; ++x) {
for (int y = 0; y < size; ++y) {
dot((x, y));
}
}
pair unpair(int i) {
int x = 0;
int y = 0;
bool on_x = false;
int out_mask = 1;
while (i != 0) {
if (i % 2 != 0) {
if (on_x) {
x += out_mask;
} else {
y += out_mask;
}
}
if (on_x) {
on_x = false;
out_mask *= 2;
} else {
on_x = true;
}
i #= 2;
}
return (x, y);
}
path boundary = box((-0.5, -0.5), (size + 0.5, size + 0.5));
pair previous = (0, 0);
for (int i = 1; i < size * size; ++i) {
pair next = unpair(i);
bool previous_in_range = previous.x <= size && previous.y <= size;
bool next_in_range = next.x <= size && next.y <= size;
if (previous_in_range && next_in_range) {
draw(previous -- next, arrow=Arrow, gray);
} else {
draw(previous -- next, gray+Dotted());
}
previous = next;
}
clip(boundary);
================================================
FILE: docs/assets/exhaustive-part-2/interleave-large.tex
================================================
\documentclass[11pt]{article}
\usepackage{amsmath}
\begin{document}
\begin{equation*}
\begin{split}
3^{20} &\rightarrow (47160, 48725) \\
3^{40} &\rightarrow (4005651428, 74192769) \\
3^{60} &\rightarrow (191657527975116, 14476912773621) \\
3^{80} &\rightarrow (8489200491033962112, 13032031964488297961) \\
3^{100} &\rightarrow (231900172002858385847832, 957915753008438345446493) \\
\end{split}
\end{equation*}
\end{document}
================================================
FILE: docs/assets/exhaustive-part-2/interleave-pairs-graph.asy
================================================
import graph;
size(600,400,IgnoreAspect);
pair unpair(int i) {
int x = 0;
int y = 0;
bool on_x = false;
int out_mask = 1;
while (i != 0) {
if (i % 2 != 0) {
if (on_x) {
x += out_mask;
} else {
y += out_mask;
}
}
if (on_x) {
on_x = false;
out_mask *= 2;
} else {
on_x = true;
}
i #= 2;
}
return (x, y);
}
real[] x={};
real[] y1={};
real[] y2={};
for (int i = 0; i < 10000; ++i) {
x.push(i);
y1.push(unpair(i).x);
y2.push(unpair(i).y);
}
real[] z=sqrt(3*x);
draw(graph(x,y1),red,"first element");
draw(graph(x,y2),blue,"second element");
draw(graph(x,z),black,"$\sqrt{3x}$");
xaxis(BottomTop,LeftTicks);
yaxis(LeftRight, RightTicks);
add(legend(),point(NW),(25,-25),UnFill);
================================================
FILE: docs/assets/exhaustive-part-2/interleave-triples-bits.tex
================================================
\documentclass[11pt]{article}
\usepackage{amsmath}
\usepackage{xcolor}
\begin{document}
\begin{tabular}{rcrcrcr}
0 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}0\color{red}0\color{blue}0\color{green}0 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00000, \ \color{green} \ldots 00000 \color{black})$ & $\rightarrow$ & $(0, 0, 0)$ \\
1 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}0\color{red}0\color{blue}0\color{green}1 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00000, \ \color{green} \ldots 00001 \color{black})$ & $\rightarrow$ & $(0, 0, 1)$ \\
2 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}0\color{red}0\color{blue}1\color{green}0 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00001, \ \color{green} \ldots 00000 \color{black})$ & $\rightarrow$ & $(0, 1, 0)$ \\
3 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}0\color{red}0\color{blue}1\color{green}1 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00001, \ \color{green} \ldots 00001 \color{black})$ & $\rightarrow$ & $(0, 1, 1)$ \\
4 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}0\color{red}1\color{blue}0\color{green}0 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00000, \ \color{green} \ldots 00000 \color{black})$ & $\rightarrow$ & $(1, 0, 0)$ \\
5 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}0\color{red}1\color{blue}0\color{green}1 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00000, \ \color{green} \ldots 00001 \color{black})$ & $\rightarrow$ & $(1, 0, 1)$ \\
6 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}0\color{red}1\color{blue}1\color{green}0 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00001, \ \color{green} \ldots 00000 \color{black})$ & $\rightarrow$ & $(1, 1, 0)$ \\
7 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}0\color{red}1\color{blue}1\color{green}1 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00001, \ \color{green} \ldots 00001 \color{black})$ & $\rightarrow$ & $(1, 1, 1)$ \\
8 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}1\color{red}0\color{blue}0\color{green}0 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00000, \ \color{green} \ldots 00010 \color{black})$ & $\rightarrow$ & $(0, 0, 2)$ \\
9 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}1\color{red}0\color{blue}0\color{green}1 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00000, \ \color{green} \ldots 00011 \color{black})$ & $\rightarrow$ & $(0, 0, 3)$ \\
10 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}1\color{red}0\color{blue}1\color{green}0 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00001, \ \color{green} \ldots 00010 \color{black})$ & $\rightarrow$ & $(0, 1, 2)$ \\
11 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}1\color{red}0\color{blue}1\color{green}1 & $\rightarrow$ & $(\color{red} \ldots 00000, \ \color{blue} \ldots 00001, \ \color{green} \ldots 00011 \color{black})$ & $\rightarrow$ & $(0, 1, 3)$ \\
12 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}1\color{red}1\color{blue}0\color{green}0 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00000, \ \color{green} \ldots 00010 \color{black})$ & $\rightarrow$ & $(1, 0, 2)$ \\
13 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}1\color{red}1\color{blue}0\color{green}1 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00000, \ \color{green} \ldots 00011 \color{black})$ & $\rightarrow$ & $(1, 0, 3)$ \\
14 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}1\color{red}1\color{blue}1\color{green}0 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00001, \ \color{green} \ldots 00010 \color{black})$ & $\rightarrow$ & $(1, 1, 2)$ \\
15 & $\rightarrow$ & \ldots \color{green}0\color{red}0\color{blue}0\color{green}1\color{red}1\color{blue}1\color{green}1 & $\rightarrow$ & $(\color{red} \ldots 00001, \ \color{blue} \ldots 00001, \ \color{green} \ldots 00011 \color{black})$ & $\rightarrow$ & $(1, 1, 3)$ \\
\end{tabular}
\end{document}
================================================
FILE: docs/assets/exhaustive-part-2/interleave-triples-graph.asy
================================================
import graph;
size(600,400,IgnoreAspect);
triple untriple(int i) {
int x = 0;
int y = 0;
int z = 0;
int j = 2;
int out_mask = 1;
while (i != 0) {
if (i % 2 != 0) {
if (j == 0) {
x += out_mask;
} else if (j == 1) {
y += out_mask;
} else {
z += out_mask;
}
}
if (j == 0) {
j = 2;
out_mask *= 2;
} else if (j == 1) {
j = 0;
} else {
j = 1;
}
i #= 2;
}
return (x, y, z);
}
real[] x={};
real[] y1={};
real[] y2={};
real[] y3={};
for (int i = 0; i < 10000; ++i) {
x.push(i);
y1.push(untriple(i).x);
y2.push(untriple(i).y);
y3.push(untriple(i).z);
}
real[] z=(7*x)^(1/3);
draw(graph(x,y1),red,"first element");
draw(graph(x,y2),blue,"second element");
draw(graph(x,y3),green,"third element");
draw(graph(x,z),black,"$\sqrt[3]{7x}$");
xaxis(BottomTop,LeftTicks);
yaxis(LeftRight, RightTicks);
add(legend(),point(NW),(25,-25),UnFill);
================================================
FILE: docs/assets/exhaustive-part-2/interleave-triples-large.tex
================================================
\documentclass[11pt]{article}
\usepackage{amsmath}
\begin{document}
\begin{equation*}
\begin{split}
3^{20} &\rightarrow (460, 1414, 1881) \\
3^{40} &\rightarrow (709242, 1441904, 2284385) \\
3^{60} &\rightarrow (2679879830, 1355562942, 821033137) \\
3^{80} &\rightarrow (3812501379408, 1191406597864, 8482842874549) \\
3^{100} &\rightarrow (7172636040844612, 458719279115590, 7931619284932509) \\
\end{split}
\end{equation*}
\end{document}
================================================
FILE: docs/assets/logo.asy
================================================
unitsize(1mm);
pair p1 = (25.0, -279.5970461708813);
pair p2 = (73.21397343575165, -453.91200545461675);
pair p3 = (87.46591514137958, -478.59709259527415);
pair p4 = (135.6798885771313, -87.89385577922775);
pair p5 = (139.89273037187124, -171.40290740472582);
pair p6 = (202.35864551325085, -370.4029538291187);
pair p7 = (214.32011142286873, -607.5090980498909);
pair p8 = (284.53465067912623, -562.1061442207722);
pair p9 = (310.7480582943721, -42.490901950109105);
pair p10 = (339.2519417056279, -42.490901950109105);
pair p11 = (347.00056582050587, -196.08799454538328);
pair p12 = (425.6407886662433, -408.50905162549805);
pair p13 = (435.67988857713124, -607.5090980498909);
pair p14 = (514.3201114228686, -87.89385577922775);
pair p15 = (550.5726189490025, -241.49094837450195);
pair p16 = (562.5340848586204, -478.59709259527415);
pair p17 = (576.7860265642483, -453.91200545461675);
pair p18 = (625.0, -279.5970461708813);
pair a = (0.5, sqrt(3)/2);
pair b = (0, 0);
pair c = (1, 0);
pair center = (0.5, sqrt(3)/6);
pen[] colors = new pen [] {
RGB(115, 209, 160),
RGB(86,158,118),
RGB(56,106,76),
RGB(27, 44, 34)
};
fill(p1 -- p3 -- p6 -- p5 -- cycle, colors[2]);
fill(p12 -- p17 -- p13 -- p8 -- cycle, colors[2]);
fill(p9 -- p14 -- p15 -- p11 -- cycle, colors[2]);
fill(p6 -- p12 -- p11 -- cycle, colors[2]);
fill(p3 -- p8 -- p7 -- cycle, colors[2]);
fill(p9 -- p5 -- p4 -- cycle, colors[2]);
fill(p17 -- p15 -- p18 -- cycle, colors[2]);
fill(p1 -- p2 -- p3 -- cycle, colors[1]);
fill(p3 -- p6 -- p8 -- cycle, colors[1]);
fill(p6 -- p8 -- p12 -- cycle, colors[0]);
fill(p6 -- p5 -- p11 -- cycle, colors[0]);
fill(p13 -- p8 -- p7 -- cycle, colors[1]);
fill(p13 -- p16 -- p17 -- cycle, colors[1]);
fill(p12 -- p17 -- p15 -- cycle, colors[1]);
fill(p12 -- p11 -- p15 -- cycle, colors[0]);
fill(p1 -- p5 -- p4 -- cycle, colors[1]);
fill(p9 -- p5 -- p11 -- cycle, colors[1]);
fill(p9 -- p10 -- p14 -- cycle, colors[1]);
fill(p14 -- p15 -- p18 -- cycle, colors[1]);
================================================
FILE: docs/index.md
================================================
<p align="center">
<img width="650" src="/assets/logo-and-name.svg" alt="Logo">
</p>
Malachite is an arbitrary-precision arithmetic library for [Rust](https://www.rust-lang.org/). It
achieves high performance in part by using algorithms derived from [GMP](https://gmplib.org/),
[FLINT](https://www.flintlib.org/), and [MPFR](https://www.mpfr.org/).
The documentation for Malachite is [here](https://docs.rs/malachite/latest/malachite/), and its crate is [here](https://crates.io/crates/malachite).
```rust
use malachite::num::arithmetic::traits::Factorial;
use malachite::Natural;
fn main() {
println!("{}", Natural::factorial(100));
}
```
The code above outputs the following:
```
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
```
You have to scroll to see the entire output.
Here's a more complex example, calculating the negative-one-millionth power of 3 and displaying the
result with 30 digits of precision.
```rust
use malachite::num::arithmetic::traits::Pow;
use malachite::num::conversion::string::options::ToSciOptions;
use malachite::num::conversion::traits::ToSci;
use malachite::Rational;
fn main() {
let mut options = ToSciOptions::default();
options.set_precision(30);
println!("{}", Rational::from(3).pow(-1_000_000i64).to_sci_with_options(options));
}
```
The output is this:
```
5.56263209915712886588211486263e-477122
```
Every digit is correct, except that the least-significant digit was rounded up from 2. The default
rounding mode,
[`Nearest`](https://docs.rs/malachite-base/latest/malachite_base/rounding_modes/enum.RoundingMode.html#variant.Nearest),
uses [bankers' rounding](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even), but you may
specify different rounding behavior via the options parameter.
Malachite is designed to work with very large numbers efficiently. See [here](/performance) for a
performance comparison against other libraries.
Malachite uses `no_std`, unless the `random`, `test_build`, or `bin_build` features are enabled.
To use Malachite, add the following to your project's `Cargo.toml` file:
```yaml
[dependencies.malachite]
version = "0.9.1"
```
By default, all of Malachite's features are included, but you can opt out of some of them. For
example, if you want to use `Natural` and `Integer` but not `Rational`, you can instead use
```yaml
[dependencies.malachite]
version = "0.9.1"
default-features = false
features = [ "naturals_and_integers" ]
```
The `malachite` crate re-exports three sub-crates.
- **malachite-base** ([crates.io](https://crates.io/crates/malachite-base)) is a collection of utilities
supporting the other crates. It includes
- Traits that wrap functions from the standard library, like
[`CheckedAdd`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.CheckedAdd.html);
- Traits that give extra functionality to primitive types, like
[`Gcd`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.Gcd.html),
[`FloorSqrt`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.FloorSqrt.html),
and
[`BitAccess`](https://docs.rs/malachite-base/latest/malachite_base/num/logic/traits/trait.BitAccess.html);
- Iterator-producing functions that let you generate values for testing.
- **malachite-nz** ([crates.io](https://crates.io/crates/malachite-nz)) defines two bignum types,
[`Natural`](https://docs.rs/malachite-nz/latest/malachite_nz/natural/struct.Natural.html)s and
[`Integer`](https://docs.rs/malachite-nz/latest/malachite_nz/integer/struct.Integer.html)s. The
functions defined on these types include
- All the ones you'd expect, like addition, subtraction, multiplication, and integer division;
- Implementations of
[`DivRound`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.DivRound.html),
which provides division that rounds according to a specified
[`RoundingMode`](https://docs.rs/malachite-base/latest/malachite_base/rounding_modes/enum.RoundingMode.html);
- Various mathematical functions, like implementations of
[`FloorSqrt`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.FloorSqrt.html)
and
[`Gcd`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.Gcd.html);
- Modular arithmetic functions, like implementations of
[`ModAdd`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.ModAdd.html)
and
[`ModPow`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.ModPow.html),
and of traits for arithmetic modulo a power of 2, like
[`ModPowerOf2Add`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.ModPowerOf2Add.html)
and
[`ModPowerOf2Pow`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.ModPowerOf2Pow.html);
- Various functions for logic and bit manipulation, like
[`BitAnd`](https://doc.rust-lang.org/nightly/core/ops/trait.BitAnd.html) and
[`BitAccess`](https://docs.rs/malachite-base/latest/malachite_base/num/logic/traits/trait.BitAccess.html).
If you need to explicitly include this crate as a dependency of the `malachite` crate, use the
`naturals_and_integers` or `malachite-nz` feature.
- **malachite-q** ([crates.io](https://crates.io/crates/malachite-q)) defines
[`Rational`](https://docs.rs/malachite-q/latest/malachite_q/struct.Rational.html)s. The
functions defined on this type include
- All the ones you'd expect, like addition, subtraction, multiplication, and division;
- Functions related to conversion between
[`Rational`](https://docs.rs/malachite-q/latest/malachite_q/struct.Rational.html)s and other
kinds of numbers, including primitive floats;
- Functions for Diophantine approximation;
- Functions for expressing
[`Rational`](https://docs.rs/malachite-q/latest/malachite_q/struct.Rational.html)s in
scientific notation.
If you need to explicitly include this crate as a dependency of the `malachite` crate, use the
`rationals` or `malachite-q` feature.
- **malachite-float** Arbitrary-precision floating-point numbers. These are in development, and
most features are missing.
Malachite is under active development, with many more types and features planned for the future.
Nonetheless, it is extensively tested and documented, and ready for use today. Just be aware that
its API is not stable yet, and that Malachite is licensed under LGPL 3.0.
Malachite is developed by Mikhail Hogrefe. `malachite-bigint`, a drop-in num-bigint replacement based on Malachite, was created by Steve Shi and is now maintained by Mikhail Hogrefe. Thanks to b4D8, florian1345, konstin, Rowan Hart, YunWon Jeong, Park Joon-Kyu, Antonio Mamić, OliverNChalk, shekohex, and skycloudd for additional contributions.
# FAQ
**How is "Malachite" pronounced, and what does it mean?**
"Malachite" is pronounced MA-luh-kite, or /ˈmæl.əˌkaɪt/. It is the name of
[a green gemstone](https://en.wikipedia.org/wiki/Malachite). Unfortunately, malachite does not
contain iron, which would have made it a particularly good namesake for a Rust library.
Malachite's logo is an image of a [snub cube](https://en.wikipedia.org/wiki/Snub_cube).
**When does Malachite allocate memory?**
Any `Natural` less than $$2^{64}$$ is represented inline, without allocating memory. Any `Integer`
whose absolute value is less than $$2^{64}$$ doesn't allocate either, and neither does any
`Rational` whose absolute numerator and denominator are both less than $$2^{64}$$. If you're using
a build with `--features 32_bit_limbs`, then the threshold is $$2^{32}$$ instead.
**Can I build Malachite for WebAssembly?**
Yes. If, in the future, Malachite includes code incompatible with Wasm (for example, code that uses
[rayon](https://docs.rs/rayon/latest/rayon/)), it will be possible to disable that code with cargo
flags.
# Blog Posts
<ul>
{% for post in site.posts %}
<li>
<a href="{{ post.url }}">{{ post.title }}</a>
</li>
{% endfor %}
</ul>
Copyright © 2026 Mikhail Hogrefe
================================================
FILE: docs/performance.md
================================================
---
layout: default
title: "Malachite Performance"
permalink: /performance/
theme: jekyll-theme-slate
---
# Performance
Here are some benchmarks comparing the Malachite to two other libraries:
- [`num`](https://crates.io/crates/num), the de facto standard bignum library for Rust.
- [`rug`](https://crates.io/crates/rug), a library that calls GMP, a widely used, highly-optimized
bignum library written in C.
The `num` version that is compared against is 0.4.0, and the `rug` version is 1.16.0.
The general trend is that Malachite is faster than `num` due to better algorithms, and slower than
`rug`. My guess is that the better performance of `rug` is due partly to GMP's use of inline
assembly (Malachite has none, being written entirely in safe Rust), and possibly due to operations
on Rust's slices being a little slower than C's raw pointers.
The following is just a small sample of the benchmarks that are available in Malachite. For each
benchmark, I've included the command that you can use to run it yourself. You can specify the
output file using `-o benchfile.gp`, and then use [gnuplot](http://www.gnuplot.info/) to convert
the `.gp` to your format of choice. I like SVG:
`gnuplot -e "set terminal svg; l \"benchfile.gp\"" > benchfile.svg`
## Rational addition
`cargo run --features bin_build --release -- -l 100000 -m random -b benchmark_rational_add_library_comparison -c "mean_bits_n 256"`
<p align="center">
<img width="650" src="/assets/benchmarks/2022-06-04-q-add.svg" alt="Rational addition">
</p>
The most significant operations involved in adding two rational numbers (fractions) are GCD
computation and division.
For GCD computation, `num` uses the
[binary GCD algorithm](https://en.wikipedia.org/wiki/Binary_GCD_algorithm), a quadratic algorithm.
Malachite follows GMP in using
[Lehmer's GCD algorithm](https://en.wikipedia.org/wiki/Lehmer%27s_GCD_algorithm), which takes
advantage of fast multiplication algorithms to achieve $$O(n (\log n)^2 \log \log n)$$ time.
For division, `num` uses Knuth's
[Algorithm D](https://ridiculousfish.com/blog/posts/labor-of-division-episode-iv.html), which is
also quadratic. Malachite, again following GMP, uses several division algorithms depending on the
input size. For the largest inputs, it uses a kind of
[Barrett reduction](https://en.wikipedia.org/wiki/Barrett_reduction), which takes
$$O(n \log n \log \log n)$$ time.
## Converting a Natural to a string
`cargo run --features bin_build --release -- -l 100000 -m random -b benchmark_natural_to_string_library_comparison -c "mean_bits_n 1024"`
<p align="center">
<img width="650" src="/assets/benchmarks/2022-06-04-n-to_string.svg" alt="Natural to string">
</p>
When converting a natural number to a string, `num` seems to use an $$O(n^{3/2})$$ algorithm.
Malachite uses a divide-and-conquer algorithm that takes $$O(n (\log n)^2 \log \log n)$$ time.
## Natural multiplication
`cargo run --features bin_build --release -- -l 20000 -m random -b benchmark_natural_mul_library_comparison -c "mean_bits_n 16384"`
<p align="center">
<img width="650" src="/assets/benchmarks/2022-06-04-n-mul.svg" alt="Natural multiplication">
</p>
For multiplying two natural numbers, `num` uses a basecase quadratic algorithm for small inputs,
then [Toom-22](https://en.wikipedia.org/wiki/Toom%E2%80%93Cook_multiplication) (Karatsuba)
multiplication for larger inputs, and finally Toom-33 for the largest ones. This means that
multiplication takes $$O(n^{\log_3 5}) \approx O(n^{1.465})$$ time.
Malachite also uses a basecase quadratic algorithm, then 13 variants of Toom-Cook multiplication,
and finally [Schönhage-Strassen (FFT) multiplication](https://en.wikipedia.org/wiki/Schonhage-Strassen_algorithm) for the largest inputs, achieving $$O(n \log n \log \log n)$$
time.
Given all of this machinery, it's a little disappointing that Malachite isn't much faster at
multiplying than `num` is, in practice. I have a few improvements in mind that should boost
Malachite's multiplication performance further.
For numbers of up to 1000 bits, all three libraries are about equally fast:
`cargo run --features bin_build --release -- -l 100000 -m random -b benchmark_natural_mul_library_comparison -c "mean_bits_n 64"`
<p align="center">
<img width="650" src="/assets/benchmarks/2022-06-04-n-mul-small.svg" alt="Natural multiplication">
</p>
## Natural addition
`cargo run --features bin_build --release -- -l 100000 -m random -b benchmark_natural_add_library_comparison -c "mean_bits_n 1024"`
<p align="center">
<img width="650" src="/assets/benchmarks/2022-06-04-n-add.svg" alt="Natural addition">
</p>
Addition of natural numbers is fast for all three libraries, being a straightforward and
linear-time affair. Interestingly, `rug` is the slowest of the bunch. I find it hard to
believe that GMP is slower than `num` or Malachite, so maybe there's some overhead
associated with FFI.
Copyright © 2026 Mikhail Hogrefe
================================================
FILE: find_replace.py
================================================
import os
import sys
def search_replace(filename, old, new):
with open(filename) as f:
new_lines = []
replaced = False
for line in f.readlines():
line = line.rstrip()
if old in line:
replaced = True
new_lines.append(line.replace(old, new))
else:
new_lines.append(line)
if replaced:
with open(filename, 'w') as out_f:
for line in new_lines:
out_f.write(line + '\n')
return replaced
old = sys.argv[1]
new = sys.argv[2]
filename_list = []
for root, directories, filenames in os.walk('.'):
for filename in filenames:
filename = os.path.join(root, filename)
if '/target/' not in filename and filename.endswith('.rs'):
filename_list.append(filename)
for root, directories, filenames in os.walk('../rust-wheels'):
for filename in filenames:
filename = os.path.join(root, filename)
if '/target/' not in filename and filename.endswith('.rs'):
filename_list.append(filename)
filename_list.sort()
line_count = 0
for filename in filename_list:
if search_replace(filename, old, new):
print(filename)
================================================
FILE: flake.nix
================================================
{
description = "malachite development environment";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
flake-utils.url = "github:numtide/flake-utils";
# Rust
rust-overlay = {
url = "github:oxalica/rust-overlay";
inputs = {
nixpkgs.follows = "nixpkgs";
flake-utils.follows = "flake-utils";
};
};
};
outputs = { self, nixpkgs, rust-overlay, flake-utils }:
flake-utils.lib.eachDefaultSystem (system:
let
overlays = [ (import rust-overlay) ];
pkgs = import nixpkgs {
inherit system overlays;
};
lib = pkgs.lib;
toolchain = pkgs.rust-bin.stable.latest.default.override {
extensions = [ "rust-src" ];
targets = [ "wasm32-unknown-unknown" ];
};
in
{
devShells.default = pkgs.mkShell {
name = "malachite";
nativeBuildInputs = [
pkgs.pkg-config
pkgs.clang
# Mold Linker for faster builds (only on Linux)
(lib.optionals pkgs.stdenv.isLinux pkgs.mold)
(lib.optionals pkgs.stdenv.isDarwin pkgs.darwin.apple_sdk.frameworks.Security)
(lib.optionals pkgs.stdenv.isDarwin pkgs.darwin.apple_sdk.frameworks.SystemConfiguration)
];
buildInputs = [
# We want the unwrapped version, wrapped comes with nixpkgs' toolchain
pkgs.rust-analyzer-unwrapped
# Finally the toolchain
toolchain
];
packages = [
pkgs.cargo-nextest
];
# Environment variables
RUST_SRC_PATH = "${toolchain}/lib/rustlib/src/rust/library";
# Needed for testing rug
LD_LIBRARY_PATH = lib.makeLibraryPath [ pkgs.gmp ];
};
});
}
================================================
FILE: katex-header.html
================================================
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.css" integrity="sha384-9eLZqc9ds8eNjO3TmqPeYcDj8n+Qfa4nuSiGYa6DjLNcv9BtN69ZIulL9+8CqC9Y" crossorigin="anonymous">
<script src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.js" integrity="sha384-K3vbOmF2BtaVai+Qk37uypf7VrgBubhQreNQe9aGsz9lB63dIFiQVlJbr92dw2Lx" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/contrib/auto-render.min.js" integrity="sha384-kmZOZB5ObwgQnS/DuDg6TScgOiWWBiVt0plIRkZCmE6rDZGrEOQeHM5PcHi+nyqe" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
renderMathInElement(document.body, {
delimiters: [
{left: "$$", right: "$$", display: true},
{left: "\\(", right: "\\)", display: false},
{left: "$", right: "$", display: false},
{left: "\\[", right: "\\]", display: true}
]
});
});
</script>
================================================
FILE: malachite/Cargo.toml
================================================
[package]
name = "malachite"
version = "0.9.1"
authors = ["Mikhail Hogrefe <mikhailhogrefe@gmail.com>"]
rust-version.workspace = true
edition.workspace = true
description = "Arbitrary-precision arithmetic, with efficient algorithms partially derived from GMP, FLINT, and MPFR."
readme = "../README.md"
homepage = "https://malachite.rs/"
repository = "https://github.com/mhogrefe/malachite"
license = "LGPL-3.0-only"
keywords = ["mathematics", "math", "numerics", "bignum"]
categories = ["mathematics"]
[dependencies]
malachite-base = { version = "0.9.1", default-features = false, path = "../malachite-base" }
malachite-nz = { version = "0.9.1", default-features = false, optional = true, path = "../malachite-nz" }
malachite-q = { version = "0.9.1", default-features = false, optional = true, path = "../malachite-q" }
malachite-float = { version = "0.9.1", default-features = false, optional = true, path = "../malachite-float" }
serde = { version = "1.0.188", optional = true, features = ["derive"] }
embed-doc-image = { version = "0.1.4", optional = true }
[features]
default = [ "std", "naturals_and_integers", "rationals" ]
std = [ "malachite-base/std", "malachite-nz/std", "malachite-q/std", "malachite-float/std" ]
enable_pyo3 = [ "malachite-nz/enable_pyo3" ]
enable_serde = [ "malachite-nz/enable_serde", "malachite-q/enable_serde", "malachite-float/enable_serde" ]
random = ["malachite-base/random", "malachite-nz/random", "malachite-q/random", "malachite-float/random"]
32_bit_limbs = ["malachite-nz/32_bit_limbs", "malachite-q/32_bit_limbs", "malachite-float/32_bit_limbs"]
naturals_and_integers = [ "malachite-nz" ]
rationals = [ "malachite-q" ]
floats = [ "malachite-float" ]
[package.metadata.docs.rs]
# docs.rs uses a nightly compiler, so by instructing it to use our `doc-images` feature we
# ensure that it will render any images that we may have in inner attribute documentation.
features = ["embed-doc-image", "random"]
rustdoc-args = [ "--html-in-header", "katex-header.html" ]
================================================
FILE: malachite/katex-header.html
================================================
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.css" integrity="sha384-9eLZqc9ds8eNjO3TmqPeYcDj8n+Qfa4nuSiGYa6DjLNcv9BtN69ZIulL9+8CqC9Y" crossorigin="anonymous">
<script src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.js" integrity="sha384-K3vbOmF2BtaVai+Qk37uypf7VrgBubhQreNQe9aGsz9lB63dIFiQVlJbr92dw2Lx" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/contrib/auto-render.min.js" integrity="sha384-kmZOZB5ObwgQnS/DuDg6TScgOiWWBiVt0plIRkZCmE6rDZGrEOQeHM5PcHi+nyqe" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
renderMathInElement(document.body, {
delimiters: [
{left: "$$", right: "$$", display: true},
{left: "\\(", right: "\\)", display: false},
{left: "$", right: "$", display: false},
{left: "\\[", right: "\\]", display: true}
]
});
});
</script>
================================================
FILE: malachite/src/lib.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
#![cfg_attr(not(any(feature = "random", feature = "std")), no_std)]
/// This module contains various functions that support the other crates. This includes many
/// numeric traits and their implementation for primitive numeric types, as well as many functions
/// for exhaustively and randomly generating values of many types.
pub mod base {
pub use malachite_base::*;
}
#[cfg(feature = "naturals_and_integers")]
#[cfg(feature = "rationals")]
#[cfg(feature = "floats")]
pub use malachite_float::Float;
#[cfg(feature = "naturals_and_integers")]
pub use malachite_nz::integer::Integer;
#[cfg(feature = "naturals_and_integers")]
pub use malachite_nz::natural::Natural;
#[cfg(feature = "naturals_and_integers")]
pub use malachite_nz::*;
#[cfg(feature = "naturals_and_integers")]
#[cfg(feature = "rationals")]
/// [`Rational`], a type representing rational numbers with arbitrarily large numerators and
/// denominators.
pub mod rational {
pub use malachite_q::*;
}
#[cfg(feature = "naturals_and_integers")]
#[cfg(feature = "rationals")]
pub use malachite_q::Rational;
/// Various types and constants dependent on whether Malachite is built using 32-bit limbs or
/// 64-bit limbs. `Limb` is the type such that `Vec`s of limbs are used to represent the bits of a
/// [`Natural`].
pub mod platform {
#[cfg(feature = "32_bit_limbs")]
pub use malachite_nz::platform_32::*;
#[cfg(not(feature = "32_bit_limbs"))]
pub use malachite_nz::platform_64::*;
}
================================================
FILE: malachite-base/.gitignore
================================================
target
*.bk
.idea*
*.iml
================================================
FILE: malachite-base/Cargo.toml
================================================
[package]
name = "malachite-base"
version = "0.9.1"
authors = ["Mikhail Hogrefe <mikhailhogrefe@gmail.com>"]
rust-version.workspace = true
edition.workspace = true
description = "A collection of utilities, including new arithmetic traits and iterators that generate all values of a type."
readme = "README.md"
homepage = "https://malachite.rs/"
repository = "https://github.com/mhogrefe/malachite"
license = "LGPL-3.0-only"
keywords = ["mathematics", "math", "numerics", "testing"]
categories = ["mathematics", "development-tools::testing"]
[lib]
name = "malachite_base"
path = "src/lib.rs"
[[bin]]
name = "malachite_base_main"
path = "src/bin.rs"
test = false
[dependencies]
itertools = { version = "0.14.0", default-features = false, features = ["use_alloc"] }
ryu = { version = "1.0.22", default-features = false }
hashbrown = { version = "0.16.1", default-features = false, features = ["default-hasher", "inline-more"] }
libm = { version = "0.2.16", default-features = false }
sha3 = { version = "0.10.8", optional = true, default-features = false }
rand = { version = "0.9.2", optional = true, default-features = false }
rand_chacha = { version = "0.9.0", optional = true, default-features = false }
getrandom = { version = "0.2", default-features = false, features = ["js"], optional = true }
clap = { version = "2.33.1", optional = true }
gnuplot = { version = "0.0.46", optional = true }
time = { version = "0.3.47", optional = true }
walkdir = { version = "2.5.0", optional = true }
[features]
default = ["std"]
std = ["itertools/use_std"]
random = ["sha3", "rand", "rand_chacha", "getrandom"]
test_build = ["gnuplot", "time", "clap", "random", "itertools/use_std"]
bin_build = ["walkdir", "test_build"]
[dev-dependencies]
malachite-base = { workspace = true, features = ["test_build"] }
maplit = "1.0.2"
[package.metadata.docs.rs]
rustdoc-args = [ "--html-in-header", "katex-header.html" ]
================================================
FILE: malachite-base/README.md
================================================
- [crates.io](https://crates.io/crates/malachite-base)
- [docs.rs](https://docs.rs/malachite-base/latest/malachite_base/)
Rather than using this crate directly, use the
[`malachite`](https://crates.io/crates/malachite) meta-crate. It re-exports all of this crate's
public members.
In `malachite-base`'s doctests you will frequently see import paths beginning with
`malachite_base::`. When using the `malachite` crate, replace this part of the paths with
`malachite::`.
# malachite-base
This crate contains many utilities that are used by the
[`malachite-nz`](https://crates.io/crates/malachite-nz) and
[`malachite-q`](https://crates.io/crates/malachite-q) crates. These utilities include
- Traits that wrap functions from the standard library, like
[`CheckedAdd`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.CheckedAdd.html).
- Traits that give extra functionality to primitive types, like
[`Gcd`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.Gcd.html),
[`FloorSqrt`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.FloorSqrt.html),
and
[`BitAccess`](https://docs.rs/malachite-base/latest/malachite_base/num/logic/traits/trait.BitAccess.html).
- Iterator-producing functions that let you generate values for testing. Here's an example of
an iterator that produces all pairs of
[`u32`](https://doc.rust-lang.org/nightly/std/primitive.u32.html)s:
```
use malachite_base::num::exhaustive::exhaustive_unsigneds;
use malachite_base::tuples::exhaustive::exhaustive_pairs_from_single;
let mut pairs = exhaustive_pairs_from_single(exhaustive_unsigneds::<u32>());
assert_eq!(
pairs.take(20).collect::<Vec<_>>(),
&[
(0, 0), (0, 1), (1, 0), (1, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1),
(3, 0), (3, 1), (2, 2), (2, 3), (3, 2), (3, 3), (0, 4), (0, 5), (1, 4), (1, 5)
]
);
```
- The
[`RoundingMode`](https://docs.rs/malachite-base/latest/malachite_base/rounding_modes/enum.RoundingMode.html)
enum, which allows you to specify the rounding behavior of various functions.
- The
[`NiceFloat`](https://docs.rs/malachite-base/latest/malachite_base/num/float/struct.NiceFloat.html) wrapper, which provides alternative implementations of
[`Eq`](https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html),
[`Ord`](https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html), and
[`Display`](https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html)
for floating-point values which are in some ways nicer than the defaults.
# Demos and benchmarks
This crate comes with a `bin` target that can be used for running demos and benchmarks.
- Almost all of the public functions in this crate have an associated demo. Running a demo
shows you a function's behavior on a large number of inputs. For example, to demo the
[`mod_pow`](https://docs.rs/malachite-base/latest/malachite_base/num/arithmetic/traits/trait.ModPow.html#tymethod.mod_pow)
function on [`u32`](https://doc.rust-lang.org/nightly/std/primitive.u32.html)s, you can use the
following command:
```
cargo run --features bin_build --release -- -l 10000 -m exhaustive -d demo_mod_pow_u32
```
This command uses the `exhaustive` mode, which generates every possible input, generally
starting with the simplest input and progressing to more complex ones. Another mode is
`random`. The `-l` flag specifies how many inputs should be generated.
- You can use a similar command to run benchmarks. The following command benchmarks various
GCD algorithms for [`u64`](https://doc.rust-lang.org/nightly/std/primitive.u64.html)s:
```text
cargo run --features bin_build --release -- -l 1000000 -m random -b \
benchmark_gcd_algorithms_u64 -o gcd-bench.gp
```
This creates a file called gcd-bench.gp. You can use gnuplot to create an SVG from it like
so:
```text
gnuplot -e "set terminal svg; l \"gcd-bench.gp\"" > gcd-bench.svg
```
The list of available demos and benchmarks is not documented anywhere; you must find them by
browsing through
[`bin_util/demo_and_bench`](https://github.com/mhogrefe/malachite/tree/master/malachite-base/src/bin_util/demo_and_bench).
# Features
- `random`: This feature provides some functions for randomly generating values. It is off by
default to avoid pulling in some extra dependencies.
- `test_build`: A large proportion of the code in this crate is only used for testing. For a
typical user, building this code would result in an unnecessarily long compilation time and
an unnecessarily large binary. Much of it is also used for testing
[`malachite-nz`](https://crates.io/crates/malachite-nz) and
[`malachite-q`](https://crates.io/crates/malachite-q), so it can't just be confined to the
`tests` directory. My solution is to only build this code when the `test_build` feature is
enabled. If you want to run unit tests, you must enable `test_build`. However, doctests don't
require it, since they only test the public interface. Enabling this feature also enables
`random`.
- `bin_build`: This feature is used to build the code for demos and benchmarks, which also
takes a long time to build. Enabling this feature also enables `test_build` and `random`.
Malachite is developed by Mikhail Hogrefe. Thanks to b4D8, florian1345, konstin, Rowan Hart, YunWon Jeong, Park Joon-Kyu, Antonio Mamić, OliverNChalk, shekohex, and skycloudd for additional contributions.
Copyright © 2026 Mikhail Hogrefe
================================================
FILE: malachite-base/katex-header.html
================================================
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.css" integrity="sha384-9eLZqc9ds8eNjO3TmqPeYcDj8n+Qfa4nuSiGYa6DjLNcv9BtN69ZIulL9+8CqC9Y" crossorigin="anonymous">
<script src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.js" integrity="sha384-K3vbOmF2BtaVai+Qk37uypf7VrgBubhQreNQe9aGsz9lB63dIFiQVlJbr92dw2Lx" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/contrib/auto-render.min.js" integrity="sha384-kmZOZB5ObwgQnS/DuDg6TScgOiWWBiVt0plIRkZCmE6rDZGrEOQeHM5PcHi+nyqe" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
renderMathInElement(document.body, {
delimiters: [
{left: "$$", right: "$$", display: true},
{left: "\\(", right: "\\)", display: false},
{left: "$", right: "$", display: false},
{left: "\\[", right: "\\]", display: true}
]
});
});
</script>
================================================
FILE: malachite-base/rustfmt.toml
================================================
max_width = 100
array_width = 100
================================================
FILE: malachite-base/src/bin.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
#![allow(
unstable_name_collisions,
clippy::assertions_on_constants,
clippy::cognitive_complexity,
clippy::many_single_char_names,
clippy::range_plus_one,
clippy::suspicious_arithmetic_impl,
clippy::suspicious_op_assign_impl,
clippy::too_many_arguments,
clippy::type_complexity,
clippy::upper_case_acronyms,
clippy::multiple_bound_locations
)]
#![warn(
clippy::cast_lossless,
clippy::explicit_into_iter_loop,
clippy::explicit_iter_loop,
clippy::filter_map_next,
clippy::large_digit_groups,
clippy::manual_filter_map,
clippy::manual_find_map,
clippy::map_flatten,
clippy::map_unwrap_or,
clippy::match_same_arms,
clippy::missing_const_for_fn,
clippy::mut_mut,
clippy::needless_borrow,
clippy::needless_continue,
clippy::needless_pass_by_value,
clippy::redundant_closure_for_method_calls,
clippy::single_match_else,
clippy::trait_duplication_in_bounds,
clippy::type_repetition_in_bounds,
clippy::uninlined_format_args,
clippy::unused_self,
clippy::if_not_else,
clippy::manual_assert,
clippy::range_plus_one,
clippy::redundant_else,
clippy::semicolon_if_nothing_returned,
clippy::cloned_instead_of_copied,
clippy::flat_map_option,
clippy::unnecessary_wraps,
clippy::unnested_or_patterns,
clippy::use_self,
clippy::trivially_copy_pass_by_ref
)]
#[cfg(feature = "bin_build")]
extern crate itertools;
#[cfg(feature = "bin_build")]
#[macro_use]
extern crate malachite_base;
#[cfg(feature = "bin_build")]
extern crate walkdir;
#[cfg(feature = "bin_build")]
use bin_util::demo_and_bench::register;
#[cfg(feature = "bin_build")]
use bin_util::generate::max_base::generate_max_base;
#[cfg(feature = "bin_build")]
use bin_util::generate::rle::generate_rle_encoding;
#[cfg(feature = "bin_build")]
use bin_util::generate::tuning_manager::{build_reference_data, test};
#[cfg(feature = "bin_build")]
use malachite_base::test_util::runner::Runner;
#[cfg(feature = "bin_build")]
use malachite_base::test_util::runner::cmd::read_command_line_arguments;
// Examples:
//
// ```
// cargo run --features bin_build -- -g max_base
// cargo run --features bin_build --release -- -l 10000 -m exhaustive -d demo_mod_pow_u32
// ```
#[cfg(feature = "bin_build")]
fn main() {
let args = read_command_line_arguments("malachite-base");
let mut runner = Runner::new();
register(&mut runner);
if let Some(demo_key) = args.demo_key {
runner.run_demo(&demo_key, args.generation_mode, &args.config, args.limit);
} else if let Some(bench_key) = args.bench_key {
runner.run_bench(
&bench_key,
args.generation_mode,
&args.config,
args.limit,
&args.out,
);
} else {
let codegen_key = args.codegen_key.unwrap();
match codegen_key.as_str() {
"max_base" => generate_max_base(),
"rle_encode" => generate_rle_encoding(),
"tm_build_reference_data" => build_reference_data(),
"tm_test" => test(),
_ => panic!("Invalid codegen key: {codegen_key}"),
}
}
}
#[cfg(not(feature = "bin_build"))]
const fn main() {}
#[cfg(feature = "bin_build")]
pub mod bin_util {
pub mod demo_and_bench;
pub mod generate;
}
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/bools/mod.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
not_assign::register(runner);
}
mod not_assign;
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/bools/not_assign.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::num::logic::traits::NotAssign;
use malachite_base::test_util::generators::bool_gen;
use malachite_base::test_util::generators::common::{GenConfig, GenMode};
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
register_demo!(runner, demo_bool_not_assign);
}
fn demo_bool_not_assign(gm: GenMode, config: &GenConfig, limit: usize) {
for mut b in bool_gen().get(gm, config).take(limit) {
let b_old = b;
b.not_assign();
println!("b := {b_old}; b.not_assign(); b = {b}");
}
}
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/chars/crement/char_to_contiguous_range.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::chars::crement::char_to_contiguous_range;
use malachite_base::test_util::bench::bucketers::char_bucketer;
use malachite_base::test_util::bench::{BenchmarkType, run_benchmark};
use malachite_base::test_util::generators::char_gen;
use malachite_base::test_util::generators::common::{GenConfig, GenMode};
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
register_demo!(runner, demo_char_to_contiguous_range);
register_bench!(runner, benchmark_char_to_contiguous_range);
}
fn demo_char_to_contiguous_range(gm: GenMode, config: &GenConfig, limit: usize) {
for c in char_gen().get(gm, config).take(limit) {
println!(
"char_to_contiguous_range({:?}) = {}",
c,
char_to_contiguous_range(c)
);
}
}
fn benchmark_char_to_contiguous_range(
gm: GenMode,
config: &GenConfig,
limit: usize,
file_name: &str,
) {
run_benchmark(
"char_to_contiguous_range(char)",
BenchmarkType::Single,
char_gen().get(gm, config),
gm.name(),
limit,
file_name,
&char_bucketer(),
&mut [("Malachite", &mut |c| no_out!(char_to_contiguous_range(c)))],
);
}
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/chars/crement/contiguous_range_to_char.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::chars::crement::contiguous_range_to_char;
use malachite_base::test_util::bench::bucketers::unsigned_direct_bucketer;
use malachite_base::test_util::bench::{BenchmarkType, run_benchmark};
use malachite_base::test_util::generators::common::{GenConfig, GenMode};
use malachite_base::test_util::generators::unsigned_gen;
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
register_demo!(runner, demo_contiguous_range_to_char);
register_bench!(runner, benchmark_contiguous_range_to_char);
}
fn demo_contiguous_range_to_char(gm: GenMode, config: &GenConfig, limit: usize) {
for u in unsigned_gen().get(gm, config).take(limit) {
println!(
"contiguous_range_to_char({}) = {:?}",
u,
contiguous_range_to_char(u)
);
}
}
fn benchmark_contiguous_range_to_char(
gm: GenMode,
config: &GenConfig,
limit: usize,
file_name: &str,
) {
run_benchmark(
"contiguous_range_to_char(u32)",
BenchmarkType::Single,
unsigned_gen().get(gm, config),
gm.name(),
limit,
file_name,
&unsigned_direct_bucketer(),
&mut [("Malachite", &mut |u| no_out!(contiguous_range_to_char(u)))],
);
}
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/chars/crement/crement.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::chars::crement::{decrement_char, increment_char};
use malachite_base::test_util::bench::bucketers::char_bucketer;
use malachite_base::test_util::bench::{BenchmarkType, run_benchmark};
use malachite_base::test_util::generators::common::{GenConfig, GenMode};
use malachite_base::test_util::generators::{char_gen_var_1, char_gen_var_2};
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
register_demo!(runner, demo_increment_char);
register_demo!(runner, demo_decrement_char);
register_bench!(runner, benchmark_increment_char);
register_bench!(runner, benchmark_decrement_char);
}
fn demo_increment_char(gm: GenMode, config: &GenConfig, limit: usize) {
for mut c in char_gen_var_1().get(gm, config).take(limit) {
let c_old = c;
increment_char(&mut c);
println!("c := {c_old:?}; increment_char(&mut c); c = {c:?}");
}
}
fn demo_decrement_char(gm: GenMode, config: &GenConfig, limit: usize) {
for mut c in char_gen_var_2().get(gm, config).take(limit) {
let c_old = c;
increment_char(&mut c);
println!("c := {c_old:?}; decrement_char(&mut c); c = {c:?}");
}
}
fn benchmark_increment_char(gm: GenMode, config: &GenConfig, limit: usize, file_name: &str) {
run_benchmark(
"increment_char(&mut char)",
BenchmarkType::Single,
char_gen_var_1().get(gm, config),
gm.name(),
limit,
file_name,
&char_bucketer(),
&mut [("Malachite", &mut |mut c| increment_char(&mut c))],
);
}
fn benchmark_decrement_char(gm: GenMode, config: &GenConfig, limit: usize, file_name: &str) {
run_benchmark(
"decrement_char(&mut char)",
BenchmarkType::Single,
char_gen_var_2().get(gm, config),
gm.name(),
limit,
file_name,
&char_bucketer(),
&mut [("Malachite", &mut |mut c| decrement_char(&mut c))],
);
}
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/chars/crement/mod.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
char_to_contiguous_range::register(runner);
contiguous_range_to_char::register(runner);
crement::register(runner);
}
pub mod char_to_contiguous_range;
pub mod contiguous_range_to_char;
#[allow(clippy::module_inception)]
pub mod crement;
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/chars/mod.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
crement::register(runner);
}
mod crement;
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/comparison/macros.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::test_util::bench::bucketers::{
pair_max_bit_bucketer, triple_max_bit_bucketer, unsigned_bit_bucketer,
};
use malachite_base::test_util::bench::{BenchmarkType, run_benchmark};
use malachite_base::test_util::generators::common::{GenConfig, GenMode};
use malachite_base::test_util::generators::{
unsigned_gen, unsigned_pair_gen_var_27, unsigned_triple_gen_var_19,
};
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
register_demo!(runner, demo_max_1);
register_demo!(runner, demo_max_2);
register_demo!(runner, demo_max_3);
register_demo!(runner, demo_min_1);
register_demo!(runner, demo_min_2);
register_demo!(runner, demo_min_3);
register_bench!(runner, benchmark_max_1);
register_bench!(runner, benchmark_max_2);
register_bench!(runner, benchmark_max_3);
register_bench!(runner, benchmark_min_1);
register_bench!(runner, benchmark_min_2);
register_bench!(runner, benchmark_min_3);
}
fn demo_max_1(gm: GenMode, config: &GenConfig, limit: usize) {
for x in unsigned_gen::<u8>().get(gm, config).take(limit) {
println!("max!({}) = {}", x, max!(x));
}
}
fn demo_max_2(gm: GenMode, config: &GenConfig, limit: usize) {
for (x, y) in unsigned_pair_gen_var_27::<u8>().get(gm, config).take(limit) {
println!("max!({}, {}) = {}", x, y, max!(x, y));
}
}
fn demo_max_3(gm: GenMode, config: &GenConfig, limit: usize) {
for (x, y, z) in unsigned_triple_gen_var_19::<u8>()
.get(gm, config)
.take(limit)
{
println!("max!({}, {}, {}) = {}", x, y, z, max!(x, y, z));
}
}
fn demo_min_1(gm: GenMode, config: &GenConfig, limit: usize) {
for x in unsigned_gen::<u8>().get(gm, config).take(limit) {
println!("min!({}) = {}", x, min!(x));
}
}
fn demo_min_2(gm: GenMode, config: &GenConfig, limit: usize) {
for (x, y) in unsigned_pair_gen_var_27::<u8>().get(gm, config).take(limit) {
println!("min!({}, {}) = {}", x, y, min!(x, y));
}
}
fn demo_min_3(gm: GenMode, config: &GenConfig, limit: usize) {
for (x, y, z) in unsigned_triple_gen_var_19::<u8>()
.get(gm, config)
.take(limit)
{
println!("min!({}, {}, {}) = {}", x, y, z, min!(x, y, z));
}
}
fn benchmark_max_1(gm: GenMode, config: &GenConfig, limit: usize, file_name: &str) {
run_benchmark(
"max!(T)",
BenchmarkType::Single,
unsigned_gen::<u8>().get(gm, config),
gm.name(),
limit,
file_name,
&unsigned_bit_bucketer(),
&mut [("Malachite", &mut |x| no_out!(max!(x)))],
);
}
fn benchmark_max_2(gm: GenMode, config: &GenConfig, limit: usize, file_name: &str) {
run_benchmark(
"max!(T, T)",
BenchmarkType::Single,
unsigned_pair_gen_var_27::<u8>().get(gm, config),
gm.name(),
limit,
file_name,
&pair_max_bit_bucketer("x", "y"),
&mut [("Malachite", &mut |(x, y)| no_out!(max!(x, y)))],
);
}
fn benchmark_max_3(gm: GenMode, config: &GenConfig, limit: usize, file_name: &str) {
run_benchmark(
"max!(T, T, T)",
BenchmarkType::Single,
unsigned_triple_gen_var_19::<u8>().get(gm, config),
gm.name(),
limit,
file_name,
&triple_max_bit_bucketer("x", "y", "z"),
&mut [("Malachite", &mut |(x, y, z)| no_out!(max!(x, y, z)))],
);
}
fn benchmark_min_1(gm: GenMode, config: &GenConfig, limit: usize, file_name: &str) {
run_benchmark(
"min!(T)",
BenchmarkType::Single,
unsigned_gen::<u8>().get(gm, config),
gm.name(),
limit,
file_name,
&unsigned_bit_bucketer(),
&mut [("Malachite", &mut |x| no_out!(min!(x)))],
);
}
fn benchmark_min_2(gm: GenMode, config: &GenConfig, limit: usize, file_name: &str) {
run_benchmark(
"min!(T, T)",
BenchmarkType::Single,
unsigned_pair_gen_var_27::<u8>().get(gm, config),
gm.name(),
limit,
file_name,
&pair_max_bit_bucketer("x", "y"),
&mut [("Malachite", &mut |(x, y)| no_out!(min!(x, y)))],
);
}
fn benchmark_min_3(gm: GenMode, config: &GenConfig, limit: usize, file_name: &str) {
run_benchmark(
"min!(T, T, T)",
BenchmarkType::Single,
unsigned_triple_gen_var_19::<u8>().get(gm, config),
gm.name(),
limit,
file_name,
&triple_max_bit_bucketer("x", "y", "z"),
&mut [("Malachite", &mut |(x, y, z)| no_out!(min!(x, y, z)))],
);
}
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/comparison/mod.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
macros::register(runner);
}
mod macros;
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/mod.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::test_util::runner::Runner;
macro_rules! unsigned_single_arg_demo {
($name: ident, $f: ident) => {
fn $name<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, limit: usize) {
for u in unsigned_gen::<T>().get(gm, config).take(limit) {
println!(concat!("{}.", stringify!($f), "() = {}"), u, u.$f());
}
}
};
}
macro_rules! signed_single_arg_demo {
($name: ident, $f: ident) => {
fn $name<T: PrimitiveSigned>(gm: GenMode, config: &GenConfig, limit: usize) {
for i in signed_gen::<T>().get(gm, config).take(limit) {
println!(concat!("({}).", stringify!($f), "() = {}"), i, i.$f());
}
}
};
}
macro_rules! unsigned_single_arg_bench {
($name: ident, $f: ident) => {
fn $name<T: PrimitiveUnsigned>(
gm: GenMode,
config: &GenConfig,
limit: usize,
file_name: &str,
) {
run_benchmark(
&format!(concat!("{}.", stringify!($f), "()"), T::NAME),
BenchmarkType::Single,
unsigned_gen::<T>().get(gm, config),
gm.name(),
limit,
file_name,
&unsigned_bit_bucketer(),
&mut [("Malachite", &mut |u| no_out!(u.$f()))],
);
}
};
}
macro_rules! signed_single_arg_bench {
($name: ident, $f: ident) => {
fn $name<T: PrimitiveSigned>(
gm: GenMode,
config: &GenConfig,
limit: usize,
file_name: &str,
) {
run_benchmark(
&format!(concat!("{}.", stringify!($f), "()"), T::NAME),
BenchmarkType::Single,
signed_gen::<T>().get(gm, config),
gm.name(),
limit,
file_name,
&signed_bit_bucketer(),
&mut [("Malachite", &mut |i| no_out!(i.$f()))],
);
}
};
}
pub(crate) fn register(runner: &mut Runner) {
bools::register(runner);
chars::register(runner);
comparison::register(runner);
num::register(runner);
rational_sequences::register(runner);
rounding_modes::register(runner);
slices::register(runner);
strings::register(runner);
vecs::register(runner);
}
mod bools;
mod chars;
mod comparison;
mod num;
mod rational_sequences;
mod rounding_modes;
mod slices;
mod strings;
mod vecs;
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/abs.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::num::basic::floats::PrimitiveFloat;
use malachite_base::num::basic::signeds::PrimitiveSigned;
use malachite_base::num::float::NiceFloat;
use malachite_base::test_util::bench::bucketers::{primitive_float_bucketer, signed_bit_bucketer};
use malachite_base::test_util::bench::{BenchmarkType, run_benchmark};
use malachite_base::test_util::generators::common::{GenConfig, GenMode};
use malachite_base::test_util::generators::{primitive_float_gen, signed_gen_var_1};
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
register_signed_demos!(runner, demo_abs_assign_signed);
register_primitive_float_demos!(runner, demo_abs_assign_primitive_float);
register_signed_benches!(runner, benchmark_abs_assign_signed);
register_primitive_float_benches!(runner, benchmark_abs_assign_primitive_float);
}
fn demo_abs_assign_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfig, limit: usize) {
for mut i in signed_gen_var_1::<T>().get(gm, config).take(limit) {
let old_i = i;
i.abs_assign();
println!("i := {old_i}; i.abs_assign(); i = {i}");
}
}
fn demo_abs_assign_primitive_float<T: PrimitiveFloat>(
gm: GenMode,
config: &GenConfig,
limit: usize,
) {
for mut f in primitive_float_gen::<T>().get(gm, config).take(limit) {
let old_f = f;
f.abs_assign();
println!(
"i := {}; i.abs_assign(); i = {}",
NiceFloat(old_f),
NiceFloat(f)
);
}
}
fn benchmark_abs_assign_signed<T: PrimitiveSigned>(
gm: GenMode,
config: &GenConfig,
limit: usize,
file_name: &str,
) {
run_benchmark(
&format!("{}.abs_assign()", T::NAME),
BenchmarkType::Single,
signed_gen_var_1::<T>().get(gm, config),
gm.name(),
limit,
file_name,
&signed_bit_bucketer(),
&mut [("Malachite", &mut |mut i| i.abs_assign())],
);
}
fn benchmark_abs_assign_primitive_float<T: PrimitiveFloat>(
gm: GenMode,
config: &GenConfig,
limit: usize,
file_name: &str,
) {
run_benchmark(
&format!("{}.abs_assign()", T::NAME),
BenchmarkType::Single,
primitive_float_gen::<T>().get(gm, config),
gm.name(),
limit,
file_name,
&primitive_float_bucketer("f"),
&mut [("Malachite", &mut |mut f| f.abs_assign())],
);
}
================================================
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/abs_diff.rs
================================================
// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
use malachite_base::num::basic::unsigneds::PrimitiveUnsigned;
use malachite_base::test_util::bench::bucketers::pair_max_bit_bucketer;
use malachite_base::test_util::bench::{BenchmarkType, run_benchmark};
use malachite_base::test_util::generators::common::{GenConfig, GenMode};
use malachite_base::test_util::generators::unsigned_pair_gen_var_27;
use malachite_base::test_util::runner::Runner;
pub(crate) fn register(runner: &mut Runner) {
register_unsigned_demos!(runner, demo_abs_diff_assign);
register_unsigned_benches!(runner, benchmark_abs_diff_assign);
}
fn demo_abs_diff_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, limit: usize) {
gitextract_3ecze51d/ ├── .envrc ├── .github/ │ ├── FUNDING.yml │ └── workflows/ │ └── rust.yml ├── .gitignore ├── .vscode/ │ ├── launch.json │ └── tasks.json ├── COPYING ├── COPYING.LESSER ├── Cargo.toml ├── LICENSE ├── README.md ├── _config.yml ├── additional-lints.py ├── build.sh ├── docs/ │ ├── CNAME │ ├── _config.yml │ ├── _includes/ │ │ └── head-custom.html │ ├── _layouts/ │ │ └── post.html │ ├── _posts/ │ │ ├── 2022-06-05-1-intro.md │ │ ├── 2022-06-05-2-exhaustive.md │ │ ├── 2022-07-03-exhaustive.md │ │ └── 2022-07-30-denominators.md │ ├── assets/ │ │ ├── denominators/ │ │ │ ├── gap-and-bound-graph.asy │ │ │ ├── gap-graph.asy │ │ │ ├── gaps.asy │ │ │ ├── j-graph.asy │ │ │ └── sixths.asy │ │ ├── exhaustive-part-2/ │ │ │ ├── cantor-graph.asy │ │ │ ├── cantor-grid.asy │ │ │ ├── cantor-large.tex │ │ │ ├── cantor-triples-large.tex │ │ │ ├── interleave-bits-1.tex │ │ │ ├── interleave-bits-2.tex │ │ │ ├── interleave-grid-filtered.asy │ │ │ ├── interleave-grid.asy │ │ │ ├── interleave-large.tex │ │ │ ├── interleave-pairs-graph.asy │ │ │ ├── interleave-triples-bits.tex │ │ │ ├── interleave-triples-graph.asy │ │ │ └── interleave-triples-large.tex │ │ └── logo.asy │ ├── index.md │ └── performance.md ├── find_replace.py ├── flake.nix ├── katex-header.html ├── malachite/ │ ├── Cargo.toml │ ├── katex-header.html │ └── src/ │ └── lib.rs ├── malachite-base/ │ ├── .gitignore │ ├── Cargo.toml │ ├── README.md │ ├── katex-header.html │ ├── rustfmt.toml │ ├── src/ │ │ ├── bin.rs │ │ ├── bin_util/ │ │ │ ├── demo_and_bench/ │ │ │ │ ├── bools/ │ │ │ │ │ ├── mod.rs │ │ │ │ │ └── not_assign.rs │ │ │ │ ├── chars/ │ │ │ │ │ ├── crement/ │ │ │ │ │ │ ├── char_to_contiguous_range.rs │ │ │ │ │ │ ├── contiguous_range_to_char.rs │ │ │ │ │ │ ├── crement.rs │ │ │ │ │ │ └── mod.rs │ │ │ │ │ └── mod.rs │ │ │ │ ├── comparison/ │ │ │ │ │ ├── macros.rs │ │ │ │ │ └── mod.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── num/ │ │ │ │ │ ├── arithmetic/ │ │ │ │ │ │ ├── abs.rs │ │ │ │ │ │ ├── abs_diff.rs │ │ │ │ │ │ ├── add_mul.rs │ │ │ │ │ │ ├── arithmetic_checked_shl.rs │ │ │ │ │ │ ├── arithmetic_checked_shr.rs │ │ │ │ │ │ ├── binomial_coefficient.rs │ │ │ │ │ │ ├── ceiling.rs │ │ │ │ │ │ ├── checked_add_mul.rs │ │ │ │ │ │ ├── checked_square.rs │ │ │ │ │ │ ├── checked_sub_mul.rs │ │ │ │ │ │ ├── coprime_with.rs │ │ │ │ │ │ ├── div_exact.rs │ │ │ │ │ │ ├── div_mod.rs │ │ │ │ │ │ ├── div_round.rs │ │ │ │ │ │ ├── divisible_by.rs │ │ │ │ │ │ ├── divisible_by_power_of_2.rs │ │ │ │ │ │ ├── eq_mod.rs │ │ │ │ │ │ ├── eq_mod_power_of_2.rs │ │ │ │ │ │ ├── extended_gcd.rs │ │ │ │ │ │ ├── factorial.rs │ │ │ │ │ │ ├── floor.rs │ │ │ │ │ │ ├── gcd.rs │ │ │ │ │ │ ├── is_power_of_2.rs │ │ │ │ │ │ ├── kronecker_symbol.rs │ │ │ │ │ │ ├── lcm.rs │ │ │ │ │ │ ├── log_base.rs │ │ │ │ │ │ ├── log_base_2.rs │ │ │ │ │ │ ├── log_base_power_of_2.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── mod_add.rs │ │ │ │ │ │ ├── mod_inverse.rs │ │ │ │ │ │ ├── mod_is_reduced.rs │ │ │ │ │ │ ├── mod_mul.rs │ │ │ │ │ │ ├── mod_neg.rs │ │ │ │ │ │ ├── mod_op.rs │ │ │ │ │ │ ├── mod_pow.rs │ │ │ │ │ │ ├── mod_power_of_2.rs │ │ │ │ │ │ ├── mod_power_of_2_add.rs │ │ │ │ │ │ ├── mod_power_of_2_inverse.rs │ │ │ │ │ │ ├── mod_power_of_2_is_reduced.rs │ │ │ │ │ │ ├── mod_power_of_2_mul.rs │ │ │ │ │ │ ├── mod_power_of_2_neg.rs │ │ │ │ │ │ ├── mod_power_of_2_pow.rs │ │ │ │ │ │ ├── mod_power_of_2_shl.rs │ │ │ │ │ │ ├── mod_power_of_2_shr.rs │ │ │ │ │ │ ├── mod_power_of_2_square.rs │ │ │ │ │ │ ├── mod_power_of_2_sub.rs │ │ │ │ │ │ ├── mod_shl.rs │ │ │ │ │ │ ├── mod_shr.rs │ │ │ │ │ │ ├── mod_square.rs │ │ │ │ │ │ ├── mod_sub.rs │ │ │ │ │ │ ├── neg.rs │ │ │ │ │ │ ├── next_power_of_2.rs │ │ │ │ │ │ ├── overflowing_abs.rs │ │ │ │ │ │ ├── overflowing_add.rs │ │ │ │ │ │ ├── overflowing_add_mul.rs │ │ │ │ │ │ ├── overflowing_div.rs │ │ │ │ │ │ ├── overflowing_mul.rs │ │ │ │ │ │ ├── overflowing_neg.rs │ │ │ │ │ │ ├── overflowing_pow.rs │ │ │ │ │ │ ├── overflowing_square.rs │ │ │ │ │ │ ├── overflowing_sub.rs │ │ │ │ │ │ ├── overflowing_sub_mul.rs │ │ │ │ │ │ ├── parity.rs │ │ │ │ │ │ ├── pow.rs │ │ │ │ │ │ ├── power_of_2.rs │ │ │ │ │ │ ├── primorial.rs │ │ │ │ │ │ ├── reciprocal.rs │ │ │ │ │ │ ├── root.rs │ │ │ │ │ │ ├── rotate.rs │ │ │ │ │ │ ├── round_to_multiple.rs │ │ │ │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ │ │ │ ├── saturating_abs.rs │ │ │ │ │ │ ├── saturating_add.rs │ │ │ │ │ │ ├── saturating_add_mul.rs │ │ │ │ │ │ ├── saturating_mul.rs │ │ │ │ │ │ ├── saturating_neg.rs │ │ │ │ │ │ ├── saturating_pow.rs │ │ │ │ │ │ ├── saturating_square.rs │ │ │ │ │ │ ├── saturating_sub.rs │ │ │ │ │ │ ├── saturating_sub_mul.rs │ │ │ │ │ │ ├── shl_round.rs │ │ │ │ │ │ ├── shr_round.rs │ │ │ │ │ │ ├── sign.rs │ │ │ │ │ │ ├── sqrt.rs │ │ │ │ │ │ ├── square.rs │ │ │ │ │ │ ├── sub_mul.rs │ │ │ │ │ │ ├── wrapping_abs.rs │ │ │ │ │ │ ├── wrapping_add.rs │ │ │ │ │ │ ├── wrapping_add_mul.rs │ │ │ │ │ │ ├── wrapping_div.rs │ │ │ │ │ │ ├── wrapping_mul.rs │ │ │ │ │ │ ├── wrapping_neg.rs │ │ │ │ │ │ ├── wrapping_pow.rs │ │ │ │ │ │ ├── wrapping_square.rs │ │ │ │ │ │ ├── wrapping_sub.rs │ │ │ │ │ │ ├── wrapping_sub_mul.rs │ │ │ │ │ │ ├── x_mul_y_to_zz.rs │ │ │ │ │ │ ├── xx_add_yy_to_zz.rs │ │ │ │ │ │ ├── xx_div_mod_y_to_qr.rs │ │ │ │ │ │ ├── xx_sub_yy_to_zz.rs │ │ │ │ │ │ ├── xxx_add_yyy_to_zzz.rs │ │ │ │ │ │ ├── xxx_sub_yyy_to_zzz.rs │ │ │ │ │ │ └── xxxx_add_yyyy_to_zzzz.rs │ │ │ │ │ ├── comparison/ │ │ │ │ │ │ ├── cmp_abs.rs │ │ │ │ │ │ ├── eq_abs.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ └── ord_abs_comparators.rs │ │ │ │ │ ├── conversion/ │ │ │ │ │ │ ├── digits/ │ │ │ │ │ │ │ ├── general_digits/ │ │ │ │ │ │ │ │ ├── from_digits.rs │ │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ │ └── to_digits.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ └── power_of_2_digits/ │ │ │ │ │ │ │ ├── from_power_of_2_digits.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ ├── power_of_2_digit_iterable.rs │ │ │ │ │ │ │ └── to_power_of_2_digits.rs │ │ │ │ │ │ ├── from/ │ │ │ │ │ │ │ ├── convertible_from.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ ├── overflowing_from.rs │ │ │ │ │ │ │ ├── rounding_from.rs │ │ │ │ │ │ │ ├── saturating_from.rs │ │ │ │ │ │ │ ├── try_from_and_exact_from.rs │ │ │ │ │ │ │ └── wrapping_from.rs │ │ │ │ │ │ ├── half/ │ │ │ │ │ │ │ ├── join_halves.rs │ │ │ │ │ │ │ ├── lower_half.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ ├── split_in_half.rs │ │ │ │ │ │ │ └── upper_half.rs │ │ │ │ │ │ ├── is_integer.rs │ │ │ │ │ │ ├── mantissa_and_exponent/ │ │ │ │ │ │ │ ├── integer_mantissa_and_exponent.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ ├── raw_mantissa_and_exponent.rs │ │ │ │ │ │ │ └── sci_mantissa_and_exponent.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── slice/ │ │ │ │ │ │ │ ├── from_other_type_slice.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ ├── vec_from_other_type.rs │ │ │ │ │ │ │ └── vec_from_other_type_slice.rs │ │ │ │ │ │ └── string/ │ │ │ │ │ │ ├── from_sci_string.rs │ │ │ │ │ │ ├── from_string.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── options/ │ │ │ │ │ │ │ ├── from_sci_string_options.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ ├── sci_size_options.rs │ │ │ │ │ │ │ └── to_sci_options.rs │ │ │ │ │ │ ├── to_sci.rs │ │ │ │ │ │ └── to_string.rs │ │ │ │ │ ├── factorization/ │ │ │ │ │ │ ├── factor.rs │ │ │ │ │ │ ├── is_power.rs │ │ │ │ │ │ ├── is_prime.rs │ │ │ │ │ │ ├── is_square.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── prime_sieve.rs │ │ │ │ │ │ ├── primes.rs │ │ │ │ │ │ └── primitive_root_prime.rs │ │ │ │ │ ├── float/ │ │ │ │ │ │ ├── basic/ │ │ │ │ │ │ │ ├── abs_negative_zero.rs │ │ │ │ │ │ │ ├── from_ordered_representation.rs │ │ │ │ │ │ │ ├── is_negative_zero.rs │ │ │ │ │ │ │ ├── max_precision_for_sci_exponent.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ ├── next_higher.rs │ │ │ │ │ │ │ ├── next_lower.rs │ │ │ │ │ │ │ ├── precision.rs │ │ │ │ │ │ │ └── to_ordered_representation.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ └── nice_float/ │ │ │ │ │ │ ├── cmp.rs │ │ │ │ │ │ ├── cmp_abs.rs │ │ │ │ │ │ ├── eq.rs │ │ │ │ │ │ ├── eq_abs.rs │ │ │ │ │ │ ├── from_str.rs │ │ │ │ │ │ ├── hash.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ └── to_string.rs │ │ │ │ │ ├── logic/ │ │ │ │ │ │ ├── bit_access/ │ │ │ │ │ │ │ ├── assign_bit.rs │ │ │ │ │ │ │ ├── clear_bit.rs │ │ │ │ │ │ │ ├── flip_bit.rs │ │ │ │ │ │ │ ├── get_bit.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ └── set_bit.rs │ │ │ │ │ │ ├── bit_block_access/ │ │ │ │ │ │ │ ├── assign_bits.rs │ │ │ │ │ │ │ ├── get_bits.rs │ │ │ │ │ │ │ └── mod.rs │ │ │ │ │ │ ├── bit_convertible/ │ │ │ │ │ │ │ ├── from_bits.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ └── to_bits.rs │ │ │ │ │ │ ├── bit_iterable.rs │ │ │ │ │ │ ├── bit_scan/ │ │ │ │ │ │ │ ├── index_of_next_false_bit.rs │ │ │ │ │ │ │ ├── index_of_next_true_bit.rs │ │ │ │ │ │ │ └── mod.rs │ │ │ │ │ │ ├── get_highest_bit.rs │ │ │ │ │ │ ├── hamming_distance.rs │ │ │ │ │ │ ├── low_mask.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── not_assign.rs │ │ │ │ │ │ └── significant_bits.rs │ │ │ │ │ └── mod.rs │ │ │ │ ├── rational_sequences/ │ │ │ │ │ ├── access/ │ │ │ │ │ │ ├── get.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ └── mutate.rs │ │ │ │ │ ├── basic/ │ │ │ │ │ │ ├── component_len.rs │ │ │ │ │ │ ├── is_empty.rs │ │ │ │ │ │ ├── is_finite.rs │ │ │ │ │ │ ├── iter.rs │ │ │ │ │ │ ├── len.rs │ │ │ │ │ │ └── mod.rs │ │ │ │ │ ├── comparison/ │ │ │ │ │ │ ├── cmp.rs │ │ │ │ │ │ ├── eq.rs │ │ │ │ │ │ ├── hash.rs │ │ │ │ │ │ └── mod.rs │ │ │ │ │ ├── conversion/ │ │ │ │ │ │ ├── clone.rs │ │ │ │ │ │ ├── from_vec.rs │ │ │ │ │ │ ├── from_vecs.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ └── to_vecs.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ └── to_string.rs │ │ │ │ ├── rounding_modes/ │ │ │ │ │ ├── clone.rs │ │ │ │ │ ├── eq.rs │ │ │ │ │ ├── from_str.rs │ │ │ │ │ ├── hash.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── neg.rs │ │ │ │ │ └── to_string.rs │ │ │ │ ├── slices/ │ │ │ │ │ ├── min_repeating_len.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── slice_leading_zeros.rs │ │ │ │ │ ├── slice_move_left.rs │ │ │ │ │ ├── slice_set_zero.rs │ │ │ │ │ ├── slice_test_zero.rs │ │ │ │ │ ├── slice_trailing_zeros.rs │ │ │ │ │ └── split_into_chunks.rs │ │ │ │ ├── strings/ │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── string_is_subset.rs │ │ │ │ │ ├── string_sort.rs │ │ │ │ │ └── string_unique.rs │ │ │ │ └── vecs/ │ │ │ │ ├── mod.rs │ │ │ │ ├── vec_delete_left.rs │ │ │ │ └── vec_pad_left.rs │ │ │ └── generate/ │ │ │ ├── max_base.rs │ │ │ ├── mod.rs │ │ │ ├── rle.rs │ │ │ └── tuning_manager.rs │ │ ├── bools/ │ │ │ ├── constants.rs │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ ├── not_assign.rs │ │ │ └── random.rs │ │ ├── chars/ │ │ │ ├── constants.rs │ │ │ ├── crement.rs │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ └── random.rs │ │ ├── comparison/ │ │ │ ├── macros.rs │ │ │ ├── mod.rs │ │ │ └── traits.rs │ │ ├── iterators/ │ │ │ ├── bit_distributor.rs │ │ │ ├── comparison.rs │ │ │ ├── iterator_cache.rs │ │ │ └── mod.rs │ │ ├── lib.rs │ │ ├── macros/ │ │ │ └── mod.rs │ │ ├── named/ │ │ │ └── mod.rs │ │ ├── nevers/ │ │ │ └── mod.rs │ │ ├── num/ │ │ │ ├── arithmetic/ │ │ │ │ ├── abs.rs │ │ │ │ ├── abs_diff.rs │ │ │ │ ├── add_mul.rs │ │ │ │ ├── arithmetic_checked_shl.rs │ │ │ │ ├── arithmetic_checked_shr.rs │ │ │ │ ├── binomial_coefficient.rs │ │ │ │ ├── ceiling.rs │ │ │ │ ├── checked_abs.rs │ │ │ │ ├── checked_add.rs │ │ │ │ ├── checked_add_mul.rs │ │ │ │ ├── checked_div.rs │ │ │ │ ├── checked_mul.rs │ │ │ │ ├── checked_neg.rs │ │ │ │ ├── checked_next_power_of_2.rs │ │ │ │ ├── checked_pow.rs │ │ │ │ ├── checked_square.rs │ │ │ │ ├── checked_sub.rs │ │ │ │ ├── checked_sub_mul.rs │ │ │ │ ├── coprime_with.rs │ │ │ │ ├── div_exact.rs │ │ │ │ ├── div_mod.rs │ │ │ │ ├── div_round.rs │ │ │ │ ├── divisible_by.rs │ │ │ │ ├── divisible_by_power_of_2.rs │ │ │ │ ├── eq_mod.rs │ │ │ │ ├── eq_mod_power_of_2.rs │ │ │ │ ├── extended_gcd.rs │ │ │ │ ├── factorial.rs │ │ │ │ ├── floor.rs │ │ │ │ ├── gcd.rs │ │ │ │ ├── is_power_of_2.rs │ │ │ │ ├── kronecker_symbol.rs │ │ │ │ ├── lcm.rs │ │ │ │ ├── log_base.rs │ │ │ │ ├── log_base_2.rs │ │ │ │ ├── log_base_power_of_2.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── mod_add.rs │ │ │ │ ├── mod_inverse.rs │ │ │ │ ├── mod_is_reduced.rs │ │ │ │ ├── mod_mul.rs │ │ │ │ ├── mod_neg.rs │ │ │ │ ├── mod_op.rs │ │ │ │ ├── mod_pow.rs │ │ │ │ ├── mod_power_of_2.rs │ │ │ │ ├── mod_power_of_2_add.rs │ │ │ │ ├── mod_power_of_2_inverse.rs │ │ │ │ ├── mod_power_of_2_is_reduced.rs │ │ │ │ ├── mod_power_of_2_mul.rs │ │ │ │ ├── mod_power_of_2_neg.rs │ │ │ │ ├── mod_power_of_2_pow.rs │ │ │ │ ├── mod_power_of_2_shl.rs │ │ │ │ ├── mod_power_of_2_shr.rs │ │ │ │ ├── mod_power_of_2_square.rs │ │ │ │ ├── mod_power_of_2_sub.rs │ │ │ │ ├── mod_shl.rs │ │ │ │ ├── mod_shr.rs │ │ │ │ ├── mod_square.rs │ │ │ │ ├── mod_sub.rs │ │ │ │ ├── neg.rs │ │ │ │ ├── next_power_of_2.rs │ │ │ │ ├── overflowing_abs.rs │ │ │ │ ├── overflowing_add.rs │ │ │ │ ├── overflowing_add_mul.rs │ │ │ │ ├── overflowing_div.rs │ │ │ │ ├── overflowing_mul.rs │ │ │ │ ├── overflowing_neg.rs │ │ │ │ ├── overflowing_pow.rs │ │ │ │ ├── overflowing_square.rs │ │ │ │ ├── overflowing_sub.rs │ │ │ │ ├── overflowing_sub_mul.rs │ │ │ │ ├── parity.rs │ │ │ │ ├── pow.rs │ │ │ │ ├── power_of_2.rs │ │ │ │ ├── primorial.rs │ │ │ │ ├── reciprocal.rs │ │ │ │ ├── root.rs │ │ │ │ ├── rotate.rs │ │ │ │ ├── round_to_multiple.rs │ │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ │ ├── saturating_abs.rs │ │ │ │ ├── saturating_add.rs │ │ │ │ ├── saturating_add_mul.rs │ │ │ │ ├── saturating_mul.rs │ │ │ │ ├── saturating_neg.rs │ │ │ │ ├── saturating_pow.rs │ │ │ │ ├── saturating_square.rs │ │ │ │ ├── saturating_sub.rs │ │ │ │ ├── saturating_sub_mul.rs │ │ │ │ ├── shl_round.rs │ │ │ │ ├── shr_round.rs │ │ │ │ ├── sign.rs │ │ │ │ ├── sqrt.rs │ │ │ │ ├── square.rs │ │ │ │ ├── sub_mul.rs │ │ │ │ ├── traits.rs │ │ │ │ ├── wrapping_abs.rs │ │ │ │ ├── wrapping_add.rs │ │ │ │ ├── wrapping_add_mul.rs │ │ │ │ ├── wrapping_div.rs │ │ │ │ ├── wrapping_mul.rs │ │ │ │ ├── wrapping_neg.rs │ │ │ │ ├── wrapping_pow.rs │ │ │ │ ├── wrapping_square.rs │ │ │ │ ├── wrapping_sub.rs │ │ │ │ ├── wrapping_sub_mul.rs │ │ │ │ ├── x_mul_y_to_zz.rs │ │ │ │ ├── xx_add_yy_to_zz.rs │ │ │ │ ├── xx_div_mod_y_to_qr.rs │ │ │ │ ├── xx_sub_yy_to_zz.rs │ │ │ │ ├── xxx_add_yyy_to_zzz.rs │ │ │ │ ├── xxx_sub_yyy_to_zzz.rs │ │ │ │ └── xxxx_add_yyyy_to_zzzz.rs │ │ │ ├── basic/ │ │ │ │ ├── floats.rs │ │ │ │ ├── integers.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── signeds.rs │ │ │ │ ├── traits.rs │ │ │ │ └── unsigneds.rs │ │ │ ├── comparison/ │ │ │ │ ├── cmp_abs.rs │ │ │ │ ├── eq_abs.rs │ │ │ │ ├── mod.rs │ │ │ │ └── traits.rs │ │ │ ├── conversion/ │ │ │ │ ├── digits/ │ │ │ │ │ ├── general_digits.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── power_of_2_digit_iterable.rs │ │ │ │ │ └── power_of_2_digits.rs │ │ │ │ ├── from.rs │ │ │ │ ├── half.rs │ │ │ │ ├── is_integer.rs │ │ │ │ ├── mantissa_and_exponent.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── slice.rs │ │ │ │ ├── string/ │ │ │ │ │ ├── from_sci_string.rs │ │ │ │ │ ├── from_string.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── options/ │ │ │ │ │ │ ├── exhaustive.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ └── random.rs │ │ │ │ │ ├── to_sci.rs │ │ │ │ │ └── to_string.rs │ │ │ │ └── traits.rs │ │ │ ├── exhaustive/ │ │ │ │ └── mod.rs │ │ │ ├── factorization/ │ │ │ │ ├── factor.rs │ │ │ │ ├── is_power.rs │ │ │ │ ├── is_prime.rs │ │ │ │ ├── is_square.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── prime_sieve.rs │ │ │ │ ├── primes.rs │ │ │ │ ├── primitive_root_prime.rs │ │ │ │ └── traits.rs │ │ │ ├── float/ │ │ │ │ └── mod.rs │ │ │ ├── iterators/ │ │ │ │ └── mod.rs │ │ │ ├── logic/ │ │ │ │ ├── bit_access.rs │ │ │ │ ├── bit_block_access.rs │ │ │ │ ├── bit_convertible.rs │ │ │ │ ├── bit_iterable.rs │ │ │ │ ├── bit_scan.rs │ │ │ │ ├── count_ones.rs │ │ │ │ ├── count_zeros.rs │ │ │ │ ├── hamming_distance.rs │ │ │ │ ├── leading_zeros.rs │ │ │ │ ├── low_mask.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── not.rs │ │ │ │ ├── significant_bits.rs │ │ │ │ ├── trailing_zeros.rs │ │ │ │ └── traits.rs │ │ │ ├── macros.rs │ │ │ ├── mod.rs │ │ │ └── random/ │ │ │ ├── geometric.rs │ │ │ ├── mod.rs │ │ │ └── striped.rs │ │ ├── options/ │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ └── random.rs │ │ ├── orderings/ │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ └── random.rs │ │ ├── platform.rs │ │ ├── random/ │ │ │ └── mod.rs │ │ ├── rational_sequences/ │ │ │ ├── access.rs │ │ │ ├── cmp.rs │ │ │ ├── conversion.rs │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ ├── random.rs │ │ │ └── to_string.rs │ │ ├── rounding_modes/ │ │ │ ├── exhaustive.rs │ │ │ ├── from_str.rs │ │ │ ├── mod.rs │ │ │ ├── neg.rs │ │ │ ├── random.rs │ │ │ └── to_string.rs │ │ ├── sets/ │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ └── random.rs │ │ ├── slices/ │ │ │ └── mod.rs │ │ ├── strings/ │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ └── random.rs │ │ ├── test_util/ │ │ │ ├── bench/ │ │ │ │ ├── bucketers.rs │ │ │ │ └── mod.rs │ │ │ ├── common/ │ │ │ │ └── mod.rs │ │ │ ├── extra_variadic/ │ │ │ │ └── mod.rs │ │ │ ├── generators/ │ │ │ │ ├── common.rs │ │ │ │ ├── exhaustive.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── random.rs │ │ │ │ └── special_random.rs │ │ │ ├── hash/ │ │ │ │ └── mod.rs │ │ │ ├── mod.rs │ │ │ ├── num/ │ │ │ │ ├── arithmetic/ │ │ │ │ │ ├── extended_gcd.rs │ │ │ │ │ ├── factorial.rs │ │ │ │ │ ├── kronecker_symbol.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── mod_inverse.rs │ │ │ │ │ ├── mod_mul.rs │ │ │ │ │ ├── mod_pow.rs │ │ │ │ │ ├── mod_power_of_2_inverse.rs │ │ │ │ │ └── primorial.rs │ │ │ │ ├── conversion/ │ │ │ │ │ ├── mod.rs │ │ │ │ │ └── string/ │ │ │ │ │ ├── from_sci_string.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ └── to_string.rs │ │ │ │ ├── exhaustive/ │ │ │ │ │ └── mod.rs │ │ │ │ ├── factorization/ │ │ │ │ │ ├── factor.rs │ │ │ │ │ ├── is_prime.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── prime_sieve.rs │ │ │ │ │ └── primes.rs │ │ │ │ ├── float/ │ │ │ │ │ └── mod.rs │ │ │ │ ├── logic/ │ │ │ │ │ ├── bit_block_access.rs │ │ │ │ │ ├── bit_convertible.rs │ │ │ │ │ └── mod.rs │ │ │ │ ├── mod.rs │ │ │ │ └── random/ │ │ │ │ ├── geometric.rs │ │ │ │ └── mod.rs │ │ │ ├── rounding_modes/ │ │ │ │ └── mod.rs │ │ │ ├── runner/ │ │ │ │ ├── cmd.rs │ │ │ │ └── mod.rs │ │ │ ├── sets/ │ │ │ │ ├── exhaustive/ │ │ │ │ │ └── mod.rs │ │ │ │ └── mod.rs │ │ │ ├── slices/ │ │ │ │ └── mod.rs │ │ │ ├── stats/ │ │ │ │ ├── common_values_map.rs │ │ │ │ ├── median.rs │ │ │ │ ├── mod.rs │ │ │ │ └── moments.rs │ │ │ └── vecs/ │ │ │ ├── exhaustive/ │ │ │ │ └── mod.rs │ │ │ ├── mod.rs │ │ │ └── random/ │ │ │ └── mod.rs │ │ ├── tuples/ │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ └── random.rs │ │ ├── unions/ │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ └── random.rs │ │ └── vecs/ │ │ ├── exhaustive.rs │ │ ├── mod.rs │ │ └── random.rs │ └── tests/ │ ├── bools/ │ │ ├── constants.rs │ │ ├── exhaustive.rs │ │ ├── not_assign.rs │ │ └── random/ │ │ ├── get_weighted_random_bool.rs │ │ ├── random_bools.rs │ │ └── weighted_random_bools.rs │ ├── chars/ │ │ ├── char_type.rs │ │ ├── constants.rs │ │ ├── crement/ │ │ │ ├── char_to_contiguous_range.rs │ │ │ ├── contiguous_range_to_char.rs │ │ │ └── crement.rs │ │ ├── exhaustive/ │ │ │ ├── ascii_chars_increasing.rs │ │ │ ├── chars_increasing.rs │ │ │ ├── exhaustive_ascii_chars.rs │ │ │ └── exhaustive_chars.rs │ │ ├── is_graphic.rs │ │ └── random/ │ │ ├── graphic_weighted_random_ascii_chars.rs │ │ ├── graphic_weighted_random_char_inclusive_range.rs │ │ ├── graphic_weighted_random_char_range.rs │ │ ├── graphic_weighted_random_chars.rs │ │ ├── random_ascii_chars.rs │ │ ├── random_char_inclusive_range.rs │ │ ├── random_char_range.rs │ │ └── random_chars.rs │ ├── comparison/ │ │ └── macros.rs │ ├── extra_variadic/ │ │ └── mod.rs │ ├── iterators/ │ │ ├── bit_distributor/ │ │ │ ├── bit_map_as_slice.rs │ │ │ ├── get_output.rs │ │ │ ├── increment_counter.rs │ │ │ ├── new.rs │ │ │ └── set_max_bits.rs │ │ ├── comparison/ │ │ │ ├── delta_directions.rs │ │ │ ├── is_strictly_ascending.rs │ │ │ ├── is_strictly_descending.rs │ │ │ ├── is_strictly_zigzagging.rs │ │ │ ├── is_weakly_ascending.rs │ │ │ ├── is_weakly_descending.rs │ │ │ └── is_weakly_zigzagging.rs │ │ ├── count_is_at_least.rs │ │ ├── count_is_at_most.rs │ │ ├── first_and_last.rs │ │ ├── is_constant.rs │ │ ├── is_unique.rs │ │ ├── iter_windows.rs │ │ ├── iterator_cache.rs │ │ ├── matching_intervals_in_iterator.rs │ │ ├── nonzero_values.rs │ │ ├── prefix_to_string.rs │ │ ├── thue_morse_sequence.rs │ │ ├── with_special_value.rs │ │ └── with_special_values.rs │ ├── lib.rs │ ├── named/ │ │ └── mod.rs │ ├── nevers/ │ │ └── nevers.rs │ ├── num/ │ │ ├── arithmetic/ │ │ │ ├── abs.rs │ │ │ ├── abs_diff.rs │ │ │ ├── add_mul.rs │ │ │ ├── arithmetic_checked_shl.rs │ │ │ ├── arithmetic_checked_shr.rs │ │ │ ├── binomial_coefficient.rs │ │ │ ├── ceiling.rs │ │ │ ├── checked_abs.rs │ │ │ ├── checked_add_mul.rs │ │ │ ├── checked_neg.rs │ │ │ ├── checked_pow.rs │ │ │ ├── checked_square.rs │ │ │ ├── checked_sub_mul.rs │ │ │ ├── coprime_with.rs │ │ │ ├── div_exact.rs │ │ │ ├── div_mod.rs │ │ │ ├── div_round.rs │ │ │ ├── divisible_by.rs │ │ │ ├── divisible_by_power_of_2.rs │ │ │ ├── eq_mod.rs │ │ │ ├── eq_mod_power_of_2.rs │ │ │ ├── extended_gcd.rs │ │ │ ├── factorial.rs │ │ │ ├── floor.rs │ │ │ ├── gcd.rs │ │ │ ├── is_power_of_2.rs │ │ │ ├── kronecker_symbol.rs │ │ │ ├── lcm.rs │ │ │ ├── log_base.rs │ │ │ ├── log_base_2.rs │ │ │ ├── log_base_power_of_2.rs │ │ │ ├── mod_add.rs │ │ │ ├── mod_inverse.rs │ │ │ ├── mod_is_reduced.rs │ │ │ ├── mod_mul.rs │ │ │ ├── mod_neg.rs │ │ │ ├── mod_op.rs │ │ │ ├── mod_pow.rs │ │ │ ├── mod_power_of_2.rs │ │ │ ├── mod_power_of_2_add.rs │ │ │ ├── mod_power_of_2_inverse.rs │ │ │ ├── mod_power_of_2_is_reduced.rs │ │ │ ├── mod_power_of_2_mul.rs │ │ │ ├── mod_power_of_2_neg.rs │ │ │ ├── mod_power_of_2_pow.rs │ │ │ ├── mod_power_of_2_shl.rs │ │ │ ├── mod_power_of_2_shr.rs │ │ │ ├── mod_power_of_2_square.rs │ │ │ ├── mod_power_of_2_sub.rs │ │ │ ├── mod_shl.rs │ │ │ ├── mod_shr.rs │ │ │ ├── mod_square.rs │ │ │ ├── mod_sub.rs │ │ │ ├── neg.rs │ │ │ ├── next_power_of_2.rs │ │ │ ├── overflowing_abs.rs │ │ │ ├── overflowing_add.rs │ │ │ ├── overflowing_add_mul.rs │ │ │ ├── overflowing_div.rs │ │ │ ├── overflowing_mul.rs │ │ │ ├── overflowing_neg.rs │ │ │ ├── overflowing_pow.rs │ │ │ ├── overflowing_square.rs │ │ │ ├── overflowing_sub.rs │ │ │ ├── overflowing_sub_mul.rs │ │ │ ├── parity.rs │ │ │ ├── pow.rs │ │ │ ├── power_of_2.rs │ │ │ ├── primorial.rs │ │ │ ├── reciprocal.rs │ │ │ ├── root.rs │ │ │ ├── rotate.rs │ │ │ ├── round_to_multiple.rs │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ ├── saturating_abs.rs │ │ │ ├── saturating_add.rs │ │ │ ├── saturating_add_mul.rs │ │ │ ├── saturating_mul.rs │ │ │ ├── saturating_neg.rs │ │ │ ├── saturating_pow.rs │ │ │ ├── saturating_square.rs │ │ │ ├── saturating_sub.rs │ │ │ ├── saturating_sub_mul.rs │ │ │ ├── shl_round.rs │ │ │ ├── shr_round.rs │ │ │ ├── sign.rs │ │ │ ├── sqrt.rs │ │ │ ├── square.rs │ │ │ ├── sub_mul.rs │ │ │ ├── wrapping_abs.rs │ │ │ ├── wrapping_add.rs │ │ │ ├── wrapping_add_mul.rs │ │ │ ├── wrapping_div.rs │ │ │ ├── wrapping_mul.rs │ │ │ ├── wrapping_neg.rs │ │ │ ├── wrapping_pow.rs │ │ │ ├── wrapping_square.rs │ │ │ ├── wrapping_sub.rs │ │ │ ├── wrapping_sub_mul.rs │ │ │ ├── x_mul_y_to_zz.rs │ │ │ ├── xx_add_yy_to_zz.rs │ │ │ ├── xx_div_mod_y_to_qr.rs │ │ │ ├── xx_sub_yy_to_zz.rs │ │ │ ├── xxx_add_yyy_to_zzz.rs │ │ │ ├── xxx_sub_yyy_to_zzz.rs │ │ │ └── xxxx_add_yyyy_to_zzzz.rs │ │ ├── basic/ │ │ │ └── constants.rs │ │ ├── comparison/ │ │ │ ├── cmp_abs.rs │ │ │ └── eq_abs.rs │ │ ├── conversion/ │ │ │ ├── digits/ │ │ │ │ ├── general_digits/ │ │ │ │ │ ├── from_digits.rs │ │ │ │ │ └── to_digits.rs │ │ │ │ └── power_of_2_digits/ │ │ │ │ ├── from_power_of_2_digits.rs │ │ │ │ ├── power_of_2_digit_iterable.rs │ │ │ │ └── to_power_of_2_digits.rs │ │ │ ├── froms/ │ │ │ │ ├── convertible_from.rs │ │ │ │ ├── from.rs │ │ │ │ ├── overflowing_from.rs │ │ │ │ ├── rounding_from.rs │ │ │ │ ├── saturating_from.rs │ │ │ │ ├── try_from_and_exact_from.rs │ │ │ │ └── wrapping_from.rs │ │ │ ├── half/ │ │ │ │ ├── join_halves.rs │ │ │ │ ├── lower_half.rs │ │ │ │ ├── split_in_half.rs │ │ │ │ └── upper_half.rs │ │ │ ├── is_integer.rs │ │ │ ├── mantissa_and_exponent/ │ │ │ │ ├── integer_mantissa_and_exponent.rs │ │ │ │ ├── raw_mantissa_and_exponent.rs │ │ │ │ └── sci_mantissa_and_exponent.rs │ │ │ ├── slice/ │ │ │ │ ├── from_other_type_slice.rs │ │ │ │ ├── vec_from_other_type.rs │ │ │ │ └── vec_from_other_type_slice.rs │ │ │ └── string/ │ │ │ ├── from_sci_string.rs │ │ │ ├── from_string.rs │ │ │ ├── options/ │ │ │ │ ├── from_sci_string_options.rs │ │ │ │ └── to_sci_options.rs │ │ │ ├── to_sci.rs │ │ │ └── to_string.rs │ │ ├── exhaustive/ │ │ │ ├── exhaustive_finite_primitive_floats.rs │ │ │ ├── exhaustive_natural_signeds.rs │ │ │ ├── exhaustive_negative_finite_primitive_floats.rs │ │ │ ├── exhaustive_negative_primitive_floats.rs │ │ │ ├── exhaustive_negative_signeds.rs │ │ │ ├── exhaustive_nonzero_finite_primitive_floats.rs │ │ │ ├── exhaustive_nonzero_finite_primitive_floats_in_range.rs │ │ │ ├── exhaustive_nonzero_primitive_floats.rs │ │ │ ├── exhaustive_nonzero_signeds.rs │ │ │ ├── exhaustive_positive_finite_primitive_floats.rs │ │ │ ├── exhaustive_positive_finite_primitive_floats_in_range.rs │ │ │ ├── exhaustive_positive_primitive_floats.rs │ │ │ ├── exhaustive_positive_primitive_ints.rs │ │ │ ├── exhaustive_primitive_float_inclusive_range.rs │ │ │ ├── exhaustive_primitive_float_range.rs │ │ │ ├── exhaustive_primitive_floats.rs │ │ │ ├── exhaustive_primitive_floats_with_sci_exponent.rs │ │ │ ├── exhaustive_primitive_floats_with_sci_exponent_and_precision.rs │ │ │ ├── exhaustive_primitive_floats_with_sci_exponent_and_precision_in_range.rs │ │ │ ├── exhaustive_primitive_floats_with_sci_exponent_in_range.rs │ │ │ ├── exhaustive_signed_inclusive_range.rs │ │ │ ├── exhaustive_signed_range.rs │ │ │ ├── exhaustive_signeds.rs │ │ │ ├── exhaustive_unsigneds.rs │ │ │ ├── finite_primitive_floats_increasing.rs │ │ │ ├── negative_finite_primitive_floats_increasing.rs │ │ │ ├── negative_primitive_floats_increasing.rs │ │ │ ├── nonzero_finite_primitive_floats_increasing.rs │ │ │ ├── nonzero_primitive_floats_increasing.rs │ │ │ ├── positive_finite_primitive_floats_increasing.rs │ │ │ ├── positive_primitive_floats_increasing.rs │ │ │ ├── primitive_float_increasing_inclusive_range.rs │ │ │ ├── primitive_float_increasing_range.rs │ │ │ ├── primitive_floats_increasing.rs │ │ │ ├── primitive_int_increasing_inclusive_range.rs │ │ │ └── primitive_int_increasing_range.rs │ │ ├── factorization/ │ │ │ ├── factor.rs │ │ │ ├── is_power.rs │ │ │ ├── is_prime.rs │ │ │ ├── is_square.rs │ │ │ ├── prime_indicator_sequence.rs │ │ │ ├── prime_indicator_sequence_less_than.rs │ │ │ ├── prime_sieve.rs │ │ │ ├── primes.rs │ │ │ └── primitive_root_prime.rs │ │ ├── float/ │ │ │ ├── basic/ │ │ │ │ ├── abs_negative_zero.rs │ │ │ │ ├── from_ordered_representation.rs │ │ │ │ ├── is_negative_zero.rs │ │ │ │ ├── max_precision_for_sci_exponent.rs │ │ │ │ ├── next_higher.rs │ │ │ │ ├── next_lower.rs │ │ │ │ ├── precision.rs │ │ │ │ └── to_ordered_representation.rs │ │ │ └── nice_float/ │ │ │ ├── cmp.rs │ │ │ ├── cmp_abs.rs │ │ │ ├── eq.rs │ │ │ ├── eq_abs.rs │ │ │ ├── from_str.rs │ │ │ ├── hash.rs │ │ │ └── to_string.rs │ │ ├── iterators/ │ │ │ ├── bit_distributor_sequence.rs │ │ │ ├── iterator_to_bit_chunks.rs │ │ │ └── ruler_sequence.rs │ │ ├── logic/ │ │ │ ├── bit_access/ │ │ │ │ ├── assign_bit.rs │ │ │ │ ├── clear_bit.rs │ │ │ │ ├── flip_bit.rs │ │ │ │ ├── get_bit.rs │ │ │ │ └── set_bit.rs │ │ │ ├── bit_block_access/ │ │ │ │ ├── assign_bits.rs │ │ │ │ └── get_bits.rs │ │ │ ├── bit_convertible/ │ │ │ │ ├── from_bits.rs │ │ │ │ └── to_bits.rs │ │ │ ├── bit_iterable.rs │ │ │ ├── bit_scan/ │ │ │ │ ├── index_of_next_false_bit.rs │ │ │ │ └── index_of_next_true_bit.rs │ │ │ ├── get_highest_bit.rs │ │ │ ├── hamming_distance.rs │ │ │ ├── low_mask.rs │ │ │ ├── not_assign.rs │ │ │ └── significant_bits.rs │ │ └── random/ │ │ ├── geometric/ │ │ │ ├── geometric_random_natural_signeds.rs │ │ │ ├── geometric_random_negative_signeds.rs │ │ │ ├── geometric_random_nonzero_signeds.rs │ │ │ ├── geometric_random_positive_signeds.rs │ │ │ ├── geometric_random_positive_unsigneds.rs │ │ │ ├── geometric_random_signed_inclusive_range.rs │ │ │ ├── geometric_random_signed_range.rs │ │ │ ├── geometric_random_signeds.rs │ │ │ ├── geometric_random_unsigned_inclusive_range.rs │ │ │ ├── geometric_random_unsigned_range.rs │ │ │ ├── geometric_random_unsigneds.rs │ │ │ ├── get_geometric_random_signed_from_inclusive_range.rs │ │ │ └── mean.rs │ │ ├── random_finite_primitive_floats.rs │ │ ├── random_highest_bit_set_unsigneds.rs │ │ ├── random_natural_signeds.rs │ │ ├── random_negative_finite_primitive_floats.rs │ │ ├── random_negative_primitive_floats.rs │ │ ├── random_negative_signeds.rs │ │ ├── random_nonzero_finite_primitive_floats.rs │ │ ├── random_nonzero_primitive_floats.rs │ │ ├── random_nonzero_signeds.rs │ │ ├── random_positive_finite_primitive_floats.rs │ │ ├── random_positive_primitive_floats.rs │ │ ├── random_positive_signeds.rs │ │ ├── random_positive_unsigneds.rs │ │ ├── random_primitive_float_inclusive_range.rs │ │ ├── random_primitive_float_range.rs │ │ ├── random_primitive_floats.rs │ │ ├── random_primitive_ints.rs │ │ ├── random_signed_bit_chunks.rs │ │ ├── random_signed_inclusive_range.rs │ │ ├── random_signed_range.rs │ │ ├── random_unsigned_bit_chunks.rs │ │ ├── random_unsigned_inclusive_range.rs │ │ ├── random_unsigned_range.rs │ │ ├── random_unsigneds_less_than.rs │ │ ├── special_random_finite_primitive_floats.rs │ │ ├── special_random_negative_finite_primitive_floats.rs │ │ ├── special_random_negative_primitive_floats.rs │ │ ├── special_random_nonzero_finite_primitive_floats.rs │ │ ├── special_random_nonzero_primitive_floats.rs │ │ ├── special_random_positive_finite_primitive_floats.rs │ │ ├── special_random_positive_primitive_floats.rs │ │ ├── special_random_primitive_float_inclusive_range.rs │ │ ├── special_random_primitive_float_range.rs │ │ ├── special_random_primitive_floats.rs │ │ ├── striped/ │ │ │ ├── get_striped_bool_vec.rs │ │ │ ├── get_striped_unsigned_vec.rs │ │ │ ├── striped_bit_source.rs │ │ │ ├── striped_random_bool_vecs.rs │ │ │ ├── striped_random_bool_vecs_from_length_iterator.rs │ │ │ ├── striped_random_bool_vecs_length_inclusive_range.rs │ │ │ ├── striped_random_bool_vecs_length_range.rs │ │ │ ├── striped_random_bool_vecs_min_length.rs │ │ │ ├── striped_random_fixed_length_bool_vecs.rs │ │ │ ├── striped_random_fixed_length_unsigned_vecs.rs │ │ │ ├── striped_random_natural_signeds.rs │ │ │ ├── striped_random_negative_signeds.rs │ │ │ ├── striped_random_nonzero_signeds.rs │ │ │ ├── striped_random_positive_signeds.rs │ │ │ ├── striped_random_positive_unsigneds.rs │ │ │ ├── striped_random_signed_inclusive_range.rs │ │ │ ├── striped_random_signed_range.rs │ │ │ ├── striped_random_signeds.rs │ │ │ ├── striped_random_unsigned_bit_chunks.rs │ │ │ ├── striped_random_unsigned_inclusive_range.rs │ │ │ ├── striped_random_unsigned_range.rs │ │ │ ├── striped_random_unsigned_vecs.rs │ │ │ ├── striped_random_unsigned_vecs_from_length_iterator.rs │ │ │ ├── striped_random_unsigned_vecs_length_inclusive_range.rs │ │ │ ├── striped_random_unsigned_vecs_length_range.rs │ │ │ ├── striped_random_unsigned_vecs_min_length.rs │ │ │ └── striped_random_unsigneds.rs │ │ └── variable_range_generator/ │ │ ├── next_bit_chunk.rs │ │ ├── next_bool.rs │ │ ├── next_in_inclusive_range.rs │ │ ├── next_in_range.rs │ │ └── next_less_than.rs │ ├── options/ │ │ ├── exhaustive/ │ │ │ ├── exhaustive_options.rs │ │ │ └── exhaustive_somes.rs │ │ ├── option_from_str.rs │ │ └── random/ │ │ ├── random_options.rs │ │ └── random_somes.rs │ ├── orderings/ │ │ ├── exhaustive.rs │ │ ├── ordering_from_str.rs │ │ └── random.rs │ ├── random/ │ │ ├── fork.rs │ │ ├── from_bytes.rs │ │ ├── get_rng.rs │ │ └── next.rs │ ├── rational_sequences/ │ │ ├── access/ │ │ │ ├── get.rs │ │ │ └── mutate.rs │ │ ├── basic/ │ │ │ ├── component_len.rs │ │ │ ├── is_empty.rs │ │ │ ├── is_finite.rs │ │ │ ├── iter.rs │ │ │ └── len.rs │ │ ├── comparison/ │ │ │ ├── cmp.rs │ │ │ ├── eq.rs │ │ │ └── hash.rs │ │ ├── conversion/ │ │ │ ├── clone.rs │ │ │ ├── from_vec.rs │ │ │ ├── from_vecs.rs │ │ │ └── to_vecs.rs │ │ ├── exhaustive.rs │ │ ├── random.rs │ │ └── to_string.rs │ ├── rounding_modes/ │ │ ├── clone.rs │ │ ├── cmp.rs │ │ ├── eq.rs │ │ ├── exhaustive.rs │ │ ├── from_str.rs │ │ ├── hash.rs │ │ ├── neg.rs │ │ ├── random.rs │ │ ├── size.rs │ │ └── to_string.rs │ ├── sets/ │ │ ├── exhaustive/ │ │ │ ├── exhaustive_b_tree_sets.rs │ │ │ ├── exhaustive_b_tree_sets_fixed_length.rs │ │ │ ├── exhaustive_b_tree_sets_length_inclusive_range.rs │ │ │ ├── exhaustive_b_tree_sets_length_range.rs │ │ │ ├── exhaustive_b_tree_sets_min_length.rs │ │ │ ├── exhaustive_hash_sets.rs │ │ │ ├── exhaustive_hash_sets_fixed_length.rs │ │ │ ├── exhaustive_hash_sets_length_inclusive_range.rs │ │ │ ├── exhaustive_hash_sets_length_range.rs │ │ │ ├── exhaustive_hash_sets_min_length.rs │ │ │ ├── lex_b_tree_sets.rs │ │ │ ├── lex_b_tree_sets_fixed_length.rs │ │ │ ├── lex_b_tree_sets_length_inclusive_range.rs │ │ │ ├── lex_b_tree_sets_length_range.rs │ │ │ ├── lex_b_tree_sets_min_length.rs │ │ │ ├── lex_hash_sets.rs │ │ │ ├── lex_hash_sets_fixed_length.rs │ │ │ ├── lex_hash_sets_length_inclusive_range.rs │ │ │ ├── lex_hash_sets_length_range.rs │ │ │ ├── lex_hash_sets_min_length.rs │ │ │ ├── shortlex_b_tree_sets.rs │ │ │ ├── shortlex_b_tree_sets_length_inclusive_range.rs │ │ │ ├── shortlex_b_tree_sets_length_range.rs │ │ │ ├── shortlex_b_tree_sets_min_length.rs │ │ │ ├── shortlex_hash_sets.rs │ │ │ ├── shortlex_hash_sets_length_inclusive_range.rs │ │ │ ├── shortlex_hash_sets_length_range.rs │ │ │ └── shortlex_hash_sets_min_length.rs │ │ └── random/ │ │ ├── random_b_tree_sets.rs │ │ ├── random_b_tree_sets_fixed_length.rs │ │ ├── random_b_tree_sets_from_length_iterator.rs │ │ ├── random_b_tree_sets_length_inclusive_range.rs │ │ ├── random_b_tree_sets_length_range.rs │ │ ├── random_b_tree_sets_min_length.rs │ │ ├── random_hash_sets.rs │ │ ├── random_hash_sets_fixed_length.rs │ │ ├── random_hash_sets_from_length_iterator.rs │ │ ├── random_hash_sets_length_inclusive_range.rs │ │ ├── random_hash_sets_length_range.rs │ │ └── random_hash_sets_min_length.rs │ ├── slices/ │ │ ├── exhaustive_slice_permutations.rs │ │ ├── min_repeating_len.rs │ │ ├── random_slice_permutations.rs │ │ ├── random_values_from_slice.rs │ │ ├── slice_leading_zeros.rs │ │ ├── slice_move_left.rs │ │ ├── slice_set_zero.rs │ │ ├── slice_test_zero.rs │ │ ├── slice_trailing_zeros.rs │ │ └── split_into_chunks.rs │ ├── strings/ │ │ ├── exhaustive/ │ │ │ ├── exhaustive_fixed_length_strings.rs │ │ │ ├── exhaustive_fixed_length_strings_using_chars.rs │ │ │ ├── exhaustive_strings.rs │ │ │ ├── exhaustive_strings_using_chars.rs │ │ │ ├── lex_fixed_length_strings.rs │ │ │ ├── lex_fixed_length_strings_using_chars.rs │ │ │ ├── shortlex_strings.rs │ │ │ └── shortlex_strings_using_chars.rs │ │ ├── random/ │ │ │ ├── random_fixed_length_strings.rs │ │ │ ├── random_fixed_length_strings_using_chars.rs │ │ │ ├── random_strings.rs │ │ │ └── random_strings_using_chars.rs │ │ ├── string_is_subset.rs │ │ ├── string_sort.rs │ │ ├── string_unique.rs │ │ ├── strings_from_char_vecs.rs │ │ ├── to_binary_string.rs │ │ ├── to_debug_string.rs │ │ ├── to_lower_hex_string.rs │ │ ├── to_octal_string.rs │ │ └── to_upper_hex_string.rs │ ├── tuples/ │ │ ├── exhaustive/ │ │ │ ├── exhaustive_custom_tuples.rs │ │ │ ├── exhaustive_dependent_pairs.rs │ │ │ ├── exhaustive_ordered_unique_tuples.rs │ │ │ ├── exhaustive_tuples_1_input.rs │ │ │ ├── exhaustive_tuples_custom_output.rs │ │ │ ├── exhaustive_tuples_from_single.rs │ │ │ ├── exhaustive_unique_tuples.rs │ │ │ ├── exhaustive_units.rs │ │ │ ├── lex_custom_tuples.rs │ │ │ ├── lex_dependent_pairs.rs │ │ │ ├── lex_ordered_unique_tuples.rs │ │ │ ├── lex_tuples.rs │ │ │ ├── lex_tuples_from_single.rs │ │ │ └── lex_unique_tuples.rs │ │ ├── random/ │ │ │ ├── random_custom_tuples.rs │ │ │ ├── random_ordered_unique_tuples.rs │ │ │ ├── random_tuples.rs │ │ │ ├── random_tuples_from_single.rs │ │ │ ├── random_unique_tuples.rs │ │ │ └── random_units.rs │ │ └── singletons.rs │ ├── unions/ │ │ ├── clone.rs │ │ ├── debug.rs │ │ ├── display.rs │ │ ├── eq.rs │ │ ├── exhaustive/ │ │ │ ├── exhaustive_unions.rs │ │ │ └── lex_unions.rs │ │ ├── from_str.rs │ │ ├── ord.rs │ │ ├── random/ │ │ │ └── random_unions.rs │ │ └── unwrap.rs │ └── vecs/ │ ├── exhaustive/ │ │ ├── exhaustive_combined_k_compositions.rs │ │ ├── exhaustive_ordered_unique_vecs.rs │ │ ├── exhaustive_ordered_unique_vecs_fixed_length.rs │ │ ├── exhaustive_ordered_unique_vecs_length_inclusive_range.rs │ │ ├── exhaustive_ordered_unique_vecs_length_range.rs │ │ ├── exhaustive_ordered_unique_vecs_min_length.rs │ │ ├── exhaustive_unique_vecs.rs │ │ ├── exhaustive_unique_vecs_fixed_length.rs │ │ ├── exhaustive_unique_vecs_length_inclusive_range.rs │ │ ├── exhaustive_unique_vecs_length_range.rs │ │ ├── exhaustive_unique_vecs_min_length.rs │ │ ├── exhaustive_vecs.rs │ │ ├── exhaustive_vecs_fixed_length_from_single.rs │ │ ├── exhaustive_vecs_fixed_length_m_inputs.rs │ │ ├── exhaustive_vecs_from_length_iterator.rs │ │ ├── exhaustive_vecs_length_inclusive_range.rs │ │ ├── exhaustive_vecs_length_n.rs │ │ ├── exhaustive_vecs_length_range.rs │ │ ├── exhaustive_vecs_min_length.rs │ │ ├── lex_k_compositions.rs │ │ ├── lex_ordered_unique_vecs.rs │ │ ├── lex_ordered_unique_vecs_fixed_length.rs │ │ ├── lex_ordered_unique_vecs_length_inclusive_range.rs │ │ ├── lex_ordered_unique_vecs_length_range.rs │ │ ├── lex_ordered_unique_vecs_min_length.rs │ │ ├── lex_unique_vecs.rs │ │ ├── lex_unique_vecs_fixed_length.rs │ │ ├── lex_unique_vecs_length_inclusive_range.rs │ │ ├── lex_unique_vecs_length_range.rs │ │ ├── lex_unique_vecs_min_length.rs │ │ ├── lex_vecs_fixed_length_from_single.rs │ │ ├── lex_vecs_fixed_length_m_inputs.rs │ │ ├── lex_vecs_length_n.rs │ │ ├── next_bit_pattern.rs │ │ ├── shortlex_ordered_unique_vecs.rs │ │ ├── shortlex_ordered_unique_vecs_length_inclusive_range.rs │ │ ├── shortlex_ordered_unique_vecs_length_range.rs │ │ ├── shortlex_ordered_unique_vecs_min_length.rs │ │ ├── shortlex_unique_vecs.rs │ │ ├── shortlex_unique_vecs_length_inclusive_range.rs │ │ ├── shortlex_unique_vecs_length_range.rs │ │ ├── shortlex_unique_vecs_min_length.rs │ │ ├── shortlex_vecs.rs │ │ ├── shortlex_vecs_from_length_iterator.rs │ │ ├── shortlex_vecs_length_inclusive_range.rs │ │ ├── shortlex_vecs_length_range.rs │ │ └── shortlex_vecs_min_length.rs │ ├── exhaustive_vec_permutations.rs │ ├── random/ │ │ ├── random_ordered_unique_vecs.rs │ │ ├── random_ordered_unique_vecs_fixed_length.rs │ │ ├── random_ordered_unique_vecs_from_length_iterator.rs │ │ ├── random_ordered_unique_vecs_length_inclusive_range.rs │ │ ├── random_ordered_unique_vecs_length_range.rs │ │ ├── random_ordered_unique_vecs_min_length.rs │ │ ├── random_unique_vecs.rs │ │ ├── random_unique_vecs_fixed_length.rs │ │ ├── random_unique_vecs_from_length_iterator.rs │ │ ├── random_unique_vecs_length_inclusive_range.rs │ │ ├── random_unique_vecs_length_range.rs │ │ ├── random_unique_vecs_min_length.rs │ │ ├── random_vecs.rs │ │ ├── random_vecs_fixed_length.rs │ │ ├── random_vecs_fixed_length_from_single.rs │ │ ├── random_vecs_fixed_length_m_inputs.rs │ │ ├── random_vecs_from_length_iterator.rs │ │ ├── random_vecs_length_inclusive_range.rs │ │ ├── random_vecs_length_range.rs │ │ └── random_vecs_min_length.rs │ ├── random_values_from_vec.rs │ ├── random_vec_permutations.rs │ ├── vec_delete_left.rs │ ├── vec_from_str.rs │ └── vec_pad_left.rs ├── malachite-bigint/ │ ├── Cargo.toml │ ├── README.md │ └── src/ │ ├── bigint.rs │ ├── biguint.rs │ ├── error.rs │ ├── iter.rs │ ├── lib.rs │ ├── macros.rs │ └── num_bigint_conversion.rs ├── malachite-criterion-bench/ │ ├── Cargo.toml │ └── benches/ │ ├── bin.rs │ ├── natural_div.rs │ └── natural_mul.rs ├── malachite-float/ │ ├── Cargo.toml │ ├── README.md │ ├── katex-header.html │ ├── rustfmt.toml │ ├── src/ │ │ ├── arithmetic/ │ │ │ ├── abs.rs │ │ │ ├── add.rs │ │ │ ├── agm.rs │ │ │ ├── div.rs │ │ │ ├── is_power_of_2.rs │ │ │ ├── ln.rs │ │ │ ├── mod.rs │ │ │ ├── mul.rs │ │ │ ├── neg.rs │ │ │ ├── power_of_2.rs │ │ │ ├── reciprocal.rs │ │ │ ├── reciprocal_sqrt.rs │ │ │ ├── shl.rs │ │ │ ├── shl_round.rs │ │ │ ├── shr.rs │ │ │ ├── shr_round.rs │ │ │ ├── sign.rs │ │ │ ├── sqrt.rs │ │ │ ├── square.rs │ │ │ └── sub.rs │ │ ├── basic/ │ │ │ ├── classification.rs │ │ │ ├── complexity.rs │ │ │ ├── constants.rs │ │ │ ├── extended.rs │ │ │ ├── get_and_set.rs │ │ │ ├── mod.rs │ │ │ └── ulp.rs │ │ ├── bin.rs │ │ ├── bin_util/ │ │ │ └── demo_and_bench/ │ │ │ ├── arithmetic/ │ │ │ │ ├── abs.rs │ │ │ │ ├── add.rs │ │ │ │ ├── agm.rs │ │ │ │ ├── div.rs │ │ │ │ ├── is_power_of_2.rs │ │ │ │ ├── ln.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── mul.rs │ │ │ │ ├── neg.rs │ │ │ │ ├── power_of_2.rs │ │ │ │ ├── reciprocal.rs │ │ │ │ ├── reciprocal_sqrt.rs │ │ │ │ ├── shl.rs │ │ │ │ ├── shl_round.rs │ │ │ │ ├── shr.rs │ │ │ │ ├── shr_round.rs │ │ │ │ ├── sign.rs │ │ │ │ ├── sqrt.rs │ │ │ │ ├── square.rs │ │ │ │ └── sub.rs │ │ │ ├── basic/ │ │ │ │ ├── classification.rs │ │ │ │ ├── complexity.rs │ │ │ │ ├── constants.rs │ │ │ │ ├── get_and_set.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── overflow_and_underflow.rs │ │ │ │ └── ulp.rs │ │ │ ├── comparison/ │ │ │ │ ├── cmp.rs │ │ │ │ ├── cmp_abs.rs │ │ │ │ ├── eq.rs │ │ │ │ ├── eq_abs.rs │ │ │ │ ├── eq_abs_integer.rs │ │ │ │ ├── eq_abs_natural.rs │ │ │ │ ├── eq_abs_primitive_float.rs │ │ │ │ ├── eq_abs_primitive_int.rs │ │ │ │ ├── eq_abs_rational.rs │ │ │ │ ├── hash.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── partial_cmp_abs_integer.rs │ │ │ │ ├── partial_cmp_abs_natural.rs │ │ │ │ ├── partial_cmp_abs_primitive_float.rs │ │ │ │ ├── partial_cmp_abs_primitive_int.rs │ │ │ │ ├── partial_cmp_abs_rational.rs │ │ │ │ ├── partial_cmp_integer.rs │ │ │ │ ├── partial_cmp_natural.rs │ │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ │ ├── partial_cmp_rational.rs │ │ │ │ ├── partial_eq_integer.rs │ │ │ │ ├── partial_eq_natural.rs │ │ │ │ ├── partial_eq_primitive_float.rs │ │ │ │ ├── partial_eq_primitive_int.rs │ │ │ │ └── partial_eq_rational.rs │ │ │ ├── constants/ │ │ │ │ ├── gauss_constant.rs │ │ │ │ ├── lemniscate_constant.rs │ │ │ │ ├── ln_2.rs │ │ │ │ ├── log_2_e.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── one_over_pi.rs │ │ │ │ ├── one_over_sqrt_pi.rs │ │ │ │ ├── one_over_sqrt_tau.rs │ │ │ │ ├── phi.rs │ │ │ │ ├── pi.rs │ │ │ │ ├── pi_over_2.rs │ │ │ │ ├── pi_over_3.rs │ │ │ │ ├── pi_over_4.rs │ │ │ │ ├── pi_over_6.rs │ │ │ │ ├── pi_over_8.rs │ │ │ │ ├── prime_constant.rs │ │ │ │ ├── prouhet_thue_morse_constant.rs │ │ │ │ ├── sqrt_2.rs │ │ │ │ ├── sqrt_2_over_2.rs │ │ │ │ ├── sqrt_3.rs │ │ │ │ ├── sqrt_3_over_3.rs │ │ │ │ ├── sqrt_pi.rs │ │ │ │ ├── tau.rs │ │ │ │ ├── two_over_pi.rs │ │ │ │ └── two_over_sqrt_pi.rs │ │ │ ├── conversion/ │ │ │ │ ├── clone.rs │ │ │ │ ├── from_integer.rs │ │ │ │ ├── from_natural.rs │ │ │ │ ├── from_primitive_float.rs │ │ │ │ ├── from_primitive_int.rs │ │ │ │ ├── from_rational.rs │ │ │ │ ├── integer_from_float.rs │ │ │ │ ├── integer_mantissa_and_exponent.rs │ │ │ │ ├── is_integer.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── natural_from_float.rs │ │ │ │ ├── primitive_float_from_float.rs │ │ │ │ ├── primitive_int_from_float.rs │ │ │ │ ├── rational_from_float.rs │ │ │ │ ├── raw_mantissa_and_exponent.rs │ │ │ │ ├── sci_mantissa_and_exponent.rs │ │ │ │ └── string/ │ │ │ │ ├── mod.rs │ │ │ │ └── to_string.rs │ │ │ └── mod.rs │ │ ├── comparison/ │ │ │ ├── cmp.rs │ │ │ ├── cmp_abs.rs │ │ │ ├── eq.rs │ │ │ ├── eq_abs.rs │ │ │ ├── eq_abs_integer.rs │ │ │ ├── eq_abs_natural.rs │ │ │ ├── eq_abs_primitive_float.rs │ │ │ ├── eq_abs_primitive_int.rs │ │ │ ├── eq_abs_rational.rs │ │ │ ├── hash.rs │ │ │ ├── mod.rs │ │ │ ├── partial_cmp_abs_integer.rs │ │ │ ├── partial_cmp_abs_natural.rs │ │ │ ├── partial_cmp_abs_primitive_float.rs │ │ │ ├── partial_cmp_abs_primitive_int.rs │ │ │ ├── partial_cmp_abs_rational.rs │ │ │ ├── partial_cmp_integer.rs │ │ │ ├── partial_cmp_natural.rs │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ ├── partial_cmp_rational.rs │ │ │ ├── partial_eq_integer.rs │ │ │ ├── partial_eq_natural.rs │ │ │ ├── partial_eq_primitive_float.rs │ │ │ ├── partial_eq_primitive_int.rs │ │ │ └── partial_eq_rational.rs │ │ ├── constants/ │ │ │ ├── gauss_constant.rs │ │ │ ├── lemniscate_constant.rs │ │ │ ├── ln_2.rs │ │ │ ├── log_2_e.rs │ │ │ ├── mod.rs │ │ │ ├── one_over_pi.rs │ │ │ ├── one_over_sqrt_pi.rs │ │ │ ├── one_over_sqrt_tau.rs │ │ │ ├── phi.rs │ │ │ ├── pi.rs │ │ │ ├── pi_over_2.rs │ │ │ ├── pi_over_3.rs │ │ │ ├── pi_over_4.rs │ │ │ ├── pi_over_6.rs │ │ │ ├── pi_over_8.rs │ │ │ ├── prime_constant.rs │ │ │ ├── prouhet_thue_morse_constant.rs │ │ │ ├── sqrt_2.rs │ │ │ ├── sqrt_2_over_2.rs │ │ │ ├── sqrt_3.rs │ │ │ ├── sqrt_3_over_3.rs │ │ │ ├── sqrt_pi.rs │ │ │ ├── tau.rs │ │ │ ├── two_over_pi.rs │ │ │ └── two_over_sqrt_pi.rs │ │ ├── conversion/ │ │ │ ├── from_bits.rs │ │ │ ├── from_integer.rs │ │ │ ├── from_natural.rs │ │ │ ├── from_primitive_float.rs │ │ │ ├── from_primitive_int.rs │ │ │ ├── from_rational.rs │ │ │ ├── integer_from_float.rs │ │ │ ├── is_integer.rs │ │ │ ├── mantissa_and_exponent.rs │ │ │ ├── mod.rs │ │ │ ├── natural_from_float.rs │ │ │ ├── primitive_float_from_float.rs │ │ │ ├── primitive_int_from_float.rs │ │ │ ├── rational_from_float.rs │ │ │ └── string/ │ │ │ ├── from_string.rs │ │ │ ├── mod.rs │ │ │ └── to_string.rs │ │ ├── exhaustive/ │ │ │ └── mod.rs │ │ ├── lib.rs │ │ ├── random/ │ │ │ └── mod.rs │ │ └── test_util/ │ │ ├── arithmetic/ │ │ │ ├── add.rs │ │ │ ├── agm.rs │ │ │ ├── div.rs │ │ │ ├── ln.rs │ │ │ ├── mod.rs │ │ │ ├── mul.rs │ │ │ ├── power_of_2.rs │ │ │ ├── reciprocal.rs │ │ │ ├── reciprocal_sqrt.rs │ │ │ ├── shl.rs │ │ │ ├── shl_round.rs │ │ │ ├── shr.rs │ │ │ ├── shr_round.rs │ │ │ ├── sqrt.rs │ │ │ ├── square.rs │ │ │ └── sub.rs │ │ ├── bench/ │ │ │ ├── bucketers.rs │ │ │ └── mod.rs │ │ ├── common/ │ │ │ └── mod.rs │ │ ├── comparison/ │ │ │ ├── mod.rs │ │ │ └── partial_cmp_rational.rs │ │ ├── constants/ │ │ │ ├── lemniscate_constant.rs │ │ │ ├── ln_2.rs │ │ │ ├── log_2_e.rs │ │ │ ├── mod.rs │ │ │ ├── one_over_pi.rs │ │ │ ├── one_over_sqrt_pi.rs │ │ │ ├── one_over_sqrt_tau.rs │ │ │ ├── pi.rs │ │ │ ├── pi_over_3.rs │ │ │ ├── prime_constant.rs │ │ │ ├── prouhet_thue_morse_constant.rs │ │ │ ├── sqrt_2.rs │ │ │ ├── sqrt_2_over_2.rs │ │ │ ├── sqrt_3.rs │ │ │ ├── sqrt_3_over_3.rs │ │ │ └── sqrt_pi.rs │ │ ├── conversion/ │ │ │ ├── from_primitive_float.rs │ │ │ └── mod.rs │ │ ├── exhaustive/ │ │ │ └── mod.rs │ │ ├── extra_variadic/ │ │ │ └── mod.rs │ │ ├── generators/ │ │ │ ├── common.rs │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ ├── random.rs │ │ │ └── special_random.rs │ │ ├── mod.rs │ │ └── random/ │ │ └── mod.rs │ └── tests/ │ ├── arithmetic/ │ │ ├── abs.rs │ │ ├── add.rs │ │ ├── agm.rs │ │ ├── div.rs │ │ ├── is_power_of_2.rs │ │ ├── ln.rs │ │ ├── mul.rs │ │ ├── neg.rs │ │ ├── power_of_2.rs │ │ ├── reciprocal.rs │ │ ├── reciprocal_sqrt.rs │ │ ├── shl.rs │ │ ├── shl_round.rs │ │ ├── shr.rs │ │ ├── shr_round.rs │ │ ├── sign.rs │ │ ├── sqrt.rs │ │ ├── square.rs │ │ └── sub.rs │ ├── basic/ │ │ ├── classification.rs │ │ ├── complexity.rs │ │ ├── constants.rs │ │ ├── get_and_set.rs │ │ ├── named.rs │ │ ├── overflow_and_underflow.rs │ │ ├── size.rs │ │ └── ulp.rs │ ├── comparison/ │ │ ├── cmp.rs │ │ ├── cmp_abs.rs │ │ ├── eq.rs │ │ ├── eq_abs.rs │ │ ├── eq_abs_integer.rs │ │ ├── eq_abs_natural.rs │ │ ├── eq_abs_primitive_float.rs │ │ ├── eq_abs_primitive_int.rs │ │ ├── eq_abs_rational.rs │ │ ├── hash.rs │ │ ├── partial_cmp_abs_integer.rs │ │ ├── partial_cmp_abs_natural.rs │ │ ├── partial_cmp_abs_primitive_float.rs │ │ ├── partial_cmp_abs_primitive_int.rs │ │ ├── partial_cmp_abs_rational.rs │ │ ├── partial_cmp_integer.rs │ │ ├── partial_cmp_natural.rs │ │ ├── partial_cmp_primitive_float.rs │ │ ├── partial_cmp_primitive_int.rs │ │ ├── partial_cmp_rational.rs │ │ ├── partial_eq_integer.rs │ │ ├── partial_eq_natural.rs │ │ ├── partial_eq_primitive_float.rs │ │ ├── partial_eq_primitive_int.rs │ │ └── partial_eq_rational.rs │ ├── constants/ │ │ ├── gauss_constant.rs │ │ ├── lemniscate_constant.rs │ │ ├── ln_2.rs │ │ ├── log_2_e.rs │ │ ├── one_over_pi.rs │ │ ├── one_over_sqrt_pi.rs │ │ ├── one_over_sqrt_tau.rs │ │ ├── phi.rs │ │ ├── pi.rs │ │ ├── pi_over_2.rs │ │ ├── pi_over_3.rs │ │ ├── pi_over_4.rs │ │ ├── pi_over_6.rs │ │ ├── pi_over_8.rs │ │ ├── prime_constant.rs │ │ ├── prouhet_thue_morse_constant.rs │ │ ├── sqrt_2.rs │ │ ├── sqrt_2_over_2.rs │ │ ├── sqrt_3.rs │ │ ├── sqrt_3_over_3.rs │ │ ├── sqrt_pi.rs │ │ ├── tau.rs │ │ ├── two_over_pi.rs │ │ └── two_over_sqrt_pi.rs │ ├── conversion/ │ │ ├── clone.rs │ │ ├── from_integer.rs │ │ ├── from_natural.rs │ │ ├── from_primitive_float.rs │ │ ├── from_primitive_int.rs │ │ ├── from_rational.rs │ │ ├── integer_from_float.rs │ │ ├── is_integer.rs │ │ ├── mantissa_and_exponent.rs │ │ ├── natural_from_float.rs │ │ ├── primitive_float_from_float.rs │ │ ├── primitive_int_from_float.rs │ │ └── rational_from_float.rs │ ├── exhaustive/ │ │ ├── exhaustive_finite_floats.rs │ │ ├── exhaustive_floats.rs │ │ ├── exhaustive_floats_with_precision.rs │ │ ├── exhaustive_negative_finite_floats.rs │ │ ├── exhaustive_non_negative_finite_floats.rs │ │ ├── exhaustive_non_positive_finite_floats.rs │ │ ├── exhaustive_nonzero_finite_floats.rs │ │ ├── exhaustive_positive_finite_floats.rs │ │ ├── exhaustive_positive_floats_with_precision.rs │ │ ├── exhaustive_positive_floats_with_sci_exponent.rs │ │ └── exhaustive_positive_floats_with_sci_exponent_and_precision.rs │ ├── lib.rs │ └── random/ │ ├── random_finite_floats.rs │ ├── random_floats.rs │ ├── random_negative_finite_floats.rs │ ├── random_non_negative_finite_floats.rs │ ├── random_non_positive_finite_floats.rs │ ├── random_nonzero_finite_floats.rs │ ├── random_positive_finite_floats.rs │ ├── random_positive_floats_with_precision.rs │ ├── striped_random_finite_floats.rs │ ├── striped_random_floats.rs │ ├── striped_random_negative_finite_floats.rs │ ├── striped_random_non_negative_finite_floats.rs │ ├── striped_random_non_positive_finite_floats.rs │ ├── striped_random_nonzero_finite_floats.rs │ ├── striped_random_positive_finite_floats.rs │ └── striped_random_positive_floats_with_precision.rs ├── malachite-nz/ │ ├── .gitignore │ ├── Cargo.toml │ ├── README.md │ ├── build.rs │ ├── extra-tests.py │ ├── images/ │ │ └── natural-mem-layout.asy │ ├── katex-header.html │ ├── rustfmt.toml │ ├── src/ │ │ ├── bin.rs │ │ ├── bin_util/ │ │ │ ├── demo_and_bench/ │ │ │ │ ├── integer/ │ │ │ │ │ ├── arithmetic/ │ │ │ │ │ │ ├── abs.rs │ │ │ │ │ │ ├── abs_diff.rs │ │ │ │ │ │ ├── add.rs │ │ │ │ │ │ ├── add_mul.rs │ │ │ │ │ │ ├── binomial_coefficient.rs │ │ │ │ │ │ ├── div.rs │ │ │ │ │ │ ├── div_exact.rs │ │ │ │ │ │ ├── div_mod.rs │ │ │ │ │ │ ├── div_round.rs │ │ │ │ │ │ ├── divisible_by.rs │ │ │ │ │ │ ├── divisible_by_power_of_2.rs │ │ │ │ │ │ ├── eq_mod.rs │ │ │ │ │ │ ├── eq_mod_power_of_2.rs │ │ │ │ │ │ ├── extended_gcd.rs │ │ │ │ │ │ ├── kronecker_symbol.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── mod_op.rs │ │ │ │ │ │ ├── mod_power_of_2.rs │ │ │ │ │ │ ├── mul.rs │ │ │ │ │ │ ├── neg.rs │ │ │ │ │ │ ├── parity.rs │ │ │ │ │ │ ├── pow.rs │ │ │ │ │ │ ├── power_of_2.rs │ │ │ │ │ │ ├── root.rs │ │ │ │ │ │ ├── round_to_multiple.rs │ │ │ │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ │ │ │ ├── shl.rs │ │ │ │ │ │ ├── shl_round.rs │ │ │ │ │ │ ├── shr.rs │ │ │ │ │ │ ├── shr_round.rs │ │ │ │ │ │ ├── sign.rs │ │ │ │ │ │ ├── sqrt.rs │ │ │ │ │ │ ├── square.rs │ │ │ │ │ │ ├── sub.rs │ │ │ │ │ │ └── sub_mul.rs │ │ │ │ │ ├── basic/ │ │ │ │ │ │ ├── from_sign_and_abs.rs │ │ │ │ │ │ └── mod.rs │ │ │ │ │ ├── comparison/ │ │ │ │ │ │ ├── cmp.rs │ │ │ │ │ │ ├── cmp_abs.rs │ │ │ │ │ │ ├── eq.rs │ │ │ │ │ │ ├── eq_abs.rs │ │ │ │ │ │ ├── eq_abs_natural.rs │ │ │ │ │ │ ├── eq_abs_primitive_float.rs │ │ │ │ │ │ ├── eq_abs_primitive_int.rs │ │ │ │ │ │ ├── hash.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── partial_cmp_abs_natural.rs │ │ │ │ │ │ ├── partial_cmp_abs_primitive_float.rs │ │ │ │ │ │ ├── partial_cmp_abs_primitive_int.rs │ │ │ │ │ │ ├── partial_cmp_natural.rs │ │ │ │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ │ │ │ ├── partial_eq_natural.rs │ │ │ │ │ │ ├── partial_eq_primitive_float.rs │ │ │ │ │ │ └── partial_eq_primitive_int.rs │ │ │ │ │ ├── conversion/ │ │ │ │ │ │ ├── clone.rs │ │ │ │ │ │ ├── floating_point_from_integer.rs │ │ │ │ │ │ ├── from_bool.rs │ │ │ │ │ │ ├── from_floating_point.rs │ │ │ │ │ │ ├── from_natural.rs │ │ │ │ │ │ ├── from_primitive_int.rs │ │ │ │ │ │ ├── from_twos_complement_limbs.rs │ │ │ │ │ │ ├── is_integer.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── natural_from_integer.rs │ │ │ │ │ │ ├── primitive_int_from_integer.rs │ │ │ │ │ │ ├── serde.rs │ │ │ │ │ │ ├── string/ │ │ │ │ │ │ │ ├── from_sci_string.rs │ │ │ │ │ │ │ ├── from_string.rs │ │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ │ ├── to_sci.rs │ │ │ │ │ │ │ └── to_string.rs │ │ │ │ │ │ └── to_twos_complement_limbs.rs │ │ │ │ │ ├── logic/ │ │ │ │ │ │ ├── and.rs │ │ │ │ │ │ ├── assign_bit.rs │ │ │ │ │ │ ├── assign_bits.rs │ │ │ │ │ │ ├── bits.rs │ │ │ │ │ │ ├── checked_count_ones.rs │ │ │ │ │ │ ├── checked_count_zeros.rs │ │ │ │ │ │ ├── checked_hamming_distance.rs │ │ │ │ │ │ ├── clear_bit.rs │ │ │ │ │ │ ├── flip_bit.rs │ │ │ │ │ │ ├── from_bits.rs │ │ │ │ │ │ ├── get_bit.rs │ │ │ │ │ │ ├── get_bits.rs │ │ │ │ │ │ ├── index_of_next_false_bit.rs │ │ │ │ │ │ ├── index_of_next_true_bit.rs │ │ │ │ │ │ ├── low_mask.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── not.rs │ │ │ │ │ │ ├── or.rs │ │ │ │ │ │ ├── set_bit.rs │ │ │ │ │ │ ├── significant_bits.rs │ │ │ │ │ │ ├── to_bits.rs │ │ │ │ │ │ ├── trailing_zeros.rs │ │ │ │ │ │ └── xor.rs │ │ │ │ │ └── mod.rs │ │ │ │ ├── mod.rs │ │ │ │ └── natural/ │ │ │ │ ├── arithmetic/ │ │ │ │ │ ├── abs_diff.rs │ │ │ │ │ ├── add.rs │ │ │ │ │ ├── add_mul.rs │ │ │ │ │ ├── binomial_coefficient.rs │ │ │ │ │ ├── checked_sub.rs │ │ │ │ │ ├── checked_sub_mul.rs │ │ │ │ │ ├── coprime_with.rs │ │ │ │ │ ├── div.rs │ │ │ │ │ ├── div_exact.rs │ │ │ │ │ ├── div_mod.rs │ │ │ │ │ ├── div_round.rs │ │ │ │ │ ├── divisible_by.rs │ │ │ │ │ ├── divisible_by_power_of_2.rs │ │ │ │ │ ├── eq_mod.rs │ │ │ │ │ ├── eq_mod_power_of_2.rs │ │ │ │ │ ├── extended_gcd.rs │ │ │ │ │ ├── factorial.rs │ │ │ │ │ ├── gcd.rs │ │ │ │ │ ├── is_power_of_2.rs │ │ │ │ │ ├── kronecker_symbol.rs │ │ │ │ │ ├── lcm.rs │ │ │ │ │ ├── log_base.rs │ │ │ │ │ ├── log_base_2.rs │ │ │ │ │ ├── log_base_power_of_2.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── mod_add.rs │ │ │ │ │ ├── mod_inverse.rs │ │ │ │ │ ├── mod_is_reduced.rs │ │ │ │ │ ├── mod_mul.rs │ │ │ │ │ ├── mod_neg.rs │ │ │ │ │ ├── mod_op.rs │ │ │ │ │ ├── mod_pow.rs │ │ │ │ │ ├── mod_power_of_2.rs │ │ │ │ │ ├── mod_power_of_2_add.rs │ │ │ │ │ ├── mod_power_of_2_inverse.rs │ │ │ │ │ ├── mod_power_of_2_is_reduced.rs │ │ │ │ │ ├── mod_power_of_2_mul.rs │ │ │ │ │ ├── mod_power_of_2_neg.rs │ │ │ │ │ ├── mod_power_of_2_pow.rs │ │ │ │ │ ├── mod_power_of_2_shl.rs │ │ │ │ │ ├── mod_power_of_2_shr.rs │ │ │ │ │ ├── mod_power_of_2_square.rs │ │ │ │ │ ├── mod_power_of_2_sub.rs │ │ │ │ │ ├── mod_shl.rs │ │ │ │ │ ├── mod_shr.rs │ │ │ │ │ ├── mod_square.rs │ │ │ │ │ ├── mod_sub.rs │ │ │ │ │ ├── mul.rs │ │ │ │ │ ├── neg.rs │ │ │ │ │ ├── next_power_of_2.rs │ │ │ │ │ ├── parity.rs │ │ │ │ │ ├── pow.rs │ │ │ │ │ ├── power_of_2.rs │ │ │ │ │ ├── primorial.rs │ │ │ │ │ ├── root.rs │ │ │ │ │ ├── round_to_multiple.rs │ │ │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ │ │ ├── saturating_sub.rs │ │ │ │ │ ├── saturating_sub_mul.rs │ │ │ │ │ ├── shl.rs │ │ │ │ │ ├── shl_round.rs │ │ │ │ │ ├── shr.rs │ │ │ │ │ ├── shr_round.rs │ │ │ │ │ ├── sign.rs │ │ │ │ │ ├── sqrt.rs │ │ │ │ │ ├── square.rs │ │ │ │ │ ├── sub.rs │ │ │ │ │ └── sub_mul.rs │ │ │ │ ├── comparison/ │ │ │ │ │ ├── cmp.rs │ │ │ │ │ ├── eq.rs │ │ │ │ │ ├── eq_abs_primitive_float.rs │ │ │ │ │ ├── eq_abs_primitive_int.rs │ │ │ │ │ ├── hash.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── partial_cmp_abs_primitive_float.rs │ │ │ │ │ ├── partial_cmp_abs_primitive_int.rs │ │ │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ │ │ ├── partial_eq_primitive_float.rs │ │ │ │ │ └── partial_eq_primitive_int.rs │ │ │ │ ├── conversion/ │ │ │ │ │ ├── clone.rs │ │ │ │ │ ├── digits/ │ │ │ │ │ │ ├── from_digits.rs │ │ │ │ │ │ ├── from_power_of_2_digits.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── power_of_2_digits.rs │ │ │ │ │ │ ├── to_digits.rs │ │ │ │ │ │ └── to_power_of_2_digits.rs │ │ │ │ │ ├── floating_point_from_natural.rs │ │ │ │ │ ├── from_bool.rs │ │ │ │ │ ├── from_floating_point.rs │ │ │ │ │ ├── from_limbs.rs │ │ │ │ │ ├── from_primitive_int.rs │ │ │ │ │ ├── integer_mantissa_and_exponent.rs │ │ │ │ │ ├── is_integer.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── primitive_int_from_natural.rs │ │ │ │ │ ├── sci_mantissa_and_exponent.rs │ │ │ │ │ ├── serde.rs │ │ │ │ │ ├── string/ │ │ │ │ │ │ ├── from_sci_string.rs │ │ │ │ │ │ ├── from_string.rs │ │ │ │ │ │ ├── mod.rs │ │ │ │ │ │ ├── to_sci.rs │ │ │ │ │ │ └── to_string.rs │ │ │ │ │ └── to_limbs.rs │ │ │ │ ├── factorization/ │ │ │ │ │ ├── is_power.rs │ │ │ │ │ ├── is_square.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ └── primes.rs │ │ │ │ ├── logic/ │ │ │ │ │ ├── and.rs │ │ │ │ │ ├── assign_bit.rs │ │ │ │ │ ├── assign_bits.rs │ │ │ │ │ ├── bits.rs │ │ │ │ │ ├── clear_bit.rs │ │ │ │ │ ├── count_ones.rs │ │ │ │ │ ├── flip_bit.rs │ │ │ │ │ ├── from_bits.rs │ │ │ │ │ ├── get_bit.rs │ │ │ │ │ ├── get_bits.rs │ │ │ │ │ ├── hamming_distance.rs │ │ │ │ │ ├── index_of_next_false_bit.rs │ │ │ │ │ ├── index_of_next_true_bit.rs │ │ │ │ │ ├── low_mask.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── not.rs │ │ │ │ │ ├── or.rs │ │ │ │ │ ├── set_bit.rs │ │ │ │ │ ├── significant_bits.rs │ │ │ │ │ ├── to_bits.rs │ │ │ │ │ ├── trailing_zeros.rs │ │ │ │ │ └── xor.rs │ │ │ │ └── mod.rs │ │ │ └── generate/ │ │ │ ├── digits_data.rs │ │ │ ├── factorial_data.rs │ │ │ └── mod.rs │ │ ├── integer/ │ │ │ ├── arithmetic/ │ │ │ │ ├── abs.rs │ │ │ │ ├── abs_diff.rs │ │ │ │ ├── add.rs │ │ │ │ ├── add_mul.rs │ │ │ │ ├── binomial_coefficient.rs │ │ │ │ ├── div.rs │ │ │ │ ├── div_exact.rs │ │ │ │ ├── div_mod.rs │ │ │ │ ├── div_round.rs │ │ │ │ ├── divisible_by.rs │ │ │ │ ├── divisible_by_power_of_2.rs │ │ │ │ ├── eq_mod.rs │ │ │ │ ├── eq_mod_power_of_2.rs │ │ │ │ ├── extended_gcd.rs │ │ │ │ ├── kronecker_symbol.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── mod_op.rs │ │ │ │ ├── mod_power_of_2.rs │ │ │ │ ├── mul.rs │ │ │ │ ├── neg.rs │ │ │ │ ├── parity.rs │ │ │ │ ├── pow.rs │ │ │ │ ├── power_of_2.rs │ │ │ │ ├── root.rs │ │ │ │ ├── round_to_multiple.rs │ │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ │ ├── shl.rs │ │ │ │ ├── shl_round.rs │ │ │ │ ├── shr.rs │ │ │ │ ├── shr_round.rs │ │ │ │ ├── sign.rs │ │ │ │ ├── sqrt.rs │ │ │ │ ├── square.rs │ │ │ │ ├── sub.rs │ │ │ │ └── sub_mul.rs │ │ │ ├── comparison/ │ │ │ │ ├── cmp.rs │ │ │ │ ├── cmp_abs.rs │ │ │ │ ├── cmp_abs_natural.rs │ │ │ │ ├── cmp_abs_primitive_float.rs │ │ │ │ ├── cmp_abs_primitive_int.rs │ │ │ │ ├── eq_abs.rs │ │ │ │ ├── eq_abs_natural.rs │ │ │ │ ├── eq_abs_primitive_float.rs │ │ │ │ ├── eq_abs_primitive_int.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── partial_cmp_natural.rs │ │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ │ ├── partial_eq_natural.rs │ │ │ │ ├── partial_eq_primitive_float.rs │ │ │ │ └── partial_eq_primitive_int.rs │ │ │ ├── conversion/ │ │ │ │ ├── from_bool.rs │ │ │ │ ├── from_natural.rs │ │ │ │ ├── from_primitive_float.rs │ │ │ │ ├── from_primitive_int.rs │ │ │ │ ├── from_twos_complement_limbs.rs │ │ │ │ ├── is_integer.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── natural_from_integer.rs │ │ │ │ ├── primitive_float_from_integer.rs │ │ │ │ ├── primitive_int_from_integer.rs │ │ │ │ ├── pyo3.rs │ │ │ │ ├── serde.rs │ │ │ │ ├── string/ │ │ │ │ │ ├── from_sci_string.rs │ │ │ │ │ ├── from_string.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── to_sci.rs │ │ │ │ │ └── to_string.rs │ │ │ │ └── to_twos_complement_limbs.rs │ │ │ ├── exhaustive/ │ │ │ │ └── mod.rs │ │ │ ├── logic/ │ │ │ │ ├── and.rs │ │ │ │ ├── bit_access.rs │ │ │ │ ├── bit_block_access.rs │ │ │ │ ├── bit_convertible.rs │ │ │ │ ├── bit_iterable.rs │ │ │ │ ├── bit_scan.rs │ │ │ │ ├── checked_count_ones.rs │ │ │ │ ├── checked_count_zeros.rs │ │ │ │ ├── checked_hamming_distance.rs │ │ │ │ ├── low_mask.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── not.rs │ │ │ │ ├── or.rs │ │ │ │ ├── significant_bits.rs │ │ │ │ ├── trailing_zeros.rs │ │ │ │ └── xor.rs │ │ │ ├── mod.rs │ │ │ └── random/ │ │ │ └── mod.rs │ │ ├── lib.rs │ │ ├── natural/ │ │ │ ├── arithmetic/ │ │ │ │ ├── abs_diff.rs │ │ │ │ ├── add.rs │ │ │ │ ├── add_mul.rs │ │ │ │ ├── binomial_coefficient.rs │ │ │ │ ├── checked_sub.rs │ │ │ │ ├── checked_sub_mul.rs │ │ │ │ ├── coprime_with.rs │ │ │ │ ├── div.rs │ │ │ │ ├── div_exact.rs │ │ │ │ ├── div_mod.rs │ │ │ │ ├── div_round.rs │ │ │ │ ├── divisible_by.rs │ │ │ │ ├── divisible_by_power_of_2.rs │ │ │ │ ├── eq_mod.rs │ │ │ │ ├── eq_mod_power_of_2.rs │ │ │ │ ├── factorial.rs │ │ │ │ ├── float_add.rs │ │ │ │ ├── float_div.rs │ │ │ │ ├── float_extras.rs │ │ │ │ ├── float_mul.rs │ │ │ │ ├── float_reciprocal.rs │ │ │ │ ├── float_reciprocal_sqrt.rs │ │ │ │ ├── float_sqrt.rs │ │ │ │ ├── float_square.rs │ │ │ │ ├── float_sub.rs │ │ │ │ ├── gcd/ │ │ │ │ │ ├── extended_gcd.rs │ │ │ │ │ ├── half_gcd.rs │ │ │ │ │ ├── matrix_2_2.rs │ │ │ │ │ └── mod.rs │ │ │ │ ├── is_power_of_2.rs │ │ │ │ ├── kronecker_symbol.rs │ │ │ │ ├── lcm.rs │ │ │ │ ├── log_base.rs │ │ │ │ ├── log_base_2.rs │ │ │ │ ├── log_base_power_of_2.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── mod_add.rs │ │ │ │ ├── mod_inverse.rs │ │ │ │ ├── mod_is_reduced.rs │ │ │ │ ├── mod_mul.rs │ │ │ │ ├── mod_neg.rs │ │ │ │ ├── mod_op.rs │ │ │ │ ├── mod_pow.rs │ │ │ │ ├── mod_power_of_2.rs │ │ │ │ ├── mod_power_of_2_add.rs │ │ │ │ ├── mod_power_of_2_inverse.rs │ │ │ │ ├── mod_power_of_2_is_reduced.rs │ │ │ │ ├── mod_power_of_2_mul.rs │ │ │ │ ├── mod_power_of_2_neg.rs │ │ │ │ ├── mod_power_of_2_pow.rs │ │ │ │ ├── mod_power_of_2_shl.rs │ │ │ │ ├── mod_power_of_2_shr.rs │ │ │ │ ├── mod_power_of_2_square.rs │ │ │ │ ├── mod_power_of_2_sub.rs │ │ │ │ ├── mod_shl.rs │ │ │ │ ├── mod_shr.rs │ │ │ │ ├── mod_square.rs │ │ │ │ ├── mod_sub.rs │ │ │ │ ├── mul/ │ │ │ │ │ ├── context.rs │ │ │ │ │ ├── fft.rs │ │ │ │ │ ├── limb.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── mul_low.rs │ │ │ │ │ ├── mul_mod.rs │ │ │ │ │ ├── poly_eval.rs │ │ │ │ │ ├── poly_interpolate.rs │ │ │ │ │ ├── product_of_limbs.rs │ │ │ │ │ └── toom.rs │ │ │ │ ├── neg.rs │ │ │ │ ├── next_power_of_2.rs │ │ │ │ ├── parity.rs │ │ │ │ ├── pow.rs │ │ │ │ ├── power_of_2.rs │ │ │ │ ├── primorial.rs │ │ │ │ ├── root.rs │ │ │ │ ├── round_to_multiple.rs │ │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ │ ├── saturating_sub.rs │ │ │ │ ├── saturating_sub_mul.rs │ │ │ │ ├── shl.rs │ │ │ │ ├── shl_round.rs │ │ │ │ ├── shr.rs │ │ │ │ ├── shr_round.rs │ │ │ │ ├── sign.rs │ │ │ │ ├── sqrt.rs │ │ │ │ ├── square.rs │ │ │ │ ├── sub.rs │ │ │ │ └── sub_mul.rs │ │ │ ├── comparison/ │ │ │ │ ├── cmp.rs │ │ │ │ ├── eq_abs_primitive_float.rs │ │ │ │ ├── eq_abs_primitive_int.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── partial_cmp_abs_primitive_float.rs │ │ │ │ ├── partial_cmp_abs_primitive_int.rs │ │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ │ ├── partial_eq_primitive_float.rs │ │ │ │ └── partial_eq_primitive_int.rs │ │ │ ├── conversion/ │ │ │ │ ├── digits/ │ │ │ │ │ ├── general_digits.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── power_of_2_digit_iterable.rs │ │ │ │ │ └── power_of_2_digits.rs │ │ │ │ ├── from_bool.rs │ │ │ │ ├── from_limbs.rs │ │ │ │ ├── from_primitive_float.rs │ │ │ │ ├── from_primitive_int.rs │ │ │ │ ├── is_integer.rs │ │ │ │ ├── limb_count.rs │ │ │ │ ├── mantissa_and_exponent.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── primitive_float_from_natural.rs │ │ │ │ ├── primitive_int_from_natural.rs │ │ │ │ ├── pyo3.rs │ │ │ │ ├── serde.rs │ │ │ │ ├── string/ │ │ │ │ │ ├── from_sci_string.rs │ │ │ │ │ ├── from_string.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── to_sci.rs │ │ │ │ │ └── to_string.rs │ │ │ │ └── to_limbs.rs │ │ │ ├── exhaustive/ │ │ │ │ └── mod.rs │ │ │ ├── factorization/ │ │ │ │ ├── is_power.rs │ │ │ │ ├── is_square.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── primes.rs │ │ │ │ └── remove_power.rs │ │ │ ├── logic/ │ │ │ │ ├── and.rs │ │ │ │ ├── bit_access.rs │ │ │ │ ├── bit_block_access.rs │ │ │ │ ├── bit_convertible.rs │ │ │ │ ├── bit_iterable.rs │ │ │ │ ├── bit_scan.rs │ │ │ │ ├── count_ones.rs │ │ │ │ ├── hamming_distance.rs │ │ │ │ ├── low_mask.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── not.rs │ │ │ │ ├── or.rs │ │ │ │ ├── significant_bits.rs │ │ │ │ ├── trailing_zeros.rs │ │ │ │ └── xor.rs │ │ │ ├── mod.rs │ │ │ └── random/ │ │ │ └── mod.rs │ │ ├── platform_32.rs │ │ ├── platform_64.rs │ │ └── test_util/ │ │ ├── bench/ │ │ │ ├── bucketers.rs │ │ │ └── mod.rs │ │ ├── common/ │ │ │ └── mod.rs │ │ ├── extra_variadic/ │ │ │ └── mod.rs │ │ ├── generators/ │ │ │ ├── common.rs │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ ├── random.rs │ │ │ └── special_random.rs │ │ ├── integer/ │ │ │ ├── arithmetic/ │ │ │ │ ├── add.rs │ │ │ │ ├── divisible_by.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── mul.rs │ │ │ │ └── sign.rs │ │ │ ├── comparison/ │ │ │ │ ├── mod.rs │ │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ │ └── partial_eq_primitive_int.rs │ │ │ ├── conversion/ │ │ │ │ ├── mod.rs │ │ │ │ └── to_twos_complement_limbs.rs │ │ │ ├── logic/ │ │ │ │ ├── and.rs │ │ │ │ ├── checked_count_ones.rs │ │ │ │ ├── checked_count_zeros.rs │ │ │ │ ├── checked_hamming_distance.rs │ │ │ │ ├── from_bits.rs │ │ │ │ ├── index_of_next_false_bit.rs │ │ │ │ ├── index_of_next_true_bit.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── or.rs │ │ │ │ ├── to_bits.rs │ │ │ │ ├── trailing_zeros.rs │ │ │ │ └── xor.rs │ │ │ ├── mod.rs │ │ │ └── random/ │ │ │ └── mod.rs │ │ ├── mod.rs │ │ └── natural/ │ │ ├── arithmetic/ │ │ │ ├── add.rs │ │ │ ├── binomial_coefficient.rs │ │ │ ├── checked_sub.rs │ │ │ ├── div.rs │ │ │ ├── div_exact.rs │ │ │ ├── div_mod.rs │ │ │ ├── divisible_by.rs │ │ │ ├── eq_mod.rs │ │ │ ├── extended_gcd.rs │ │ │ ├── factorial.rs │ │ │ ├── gcd.rs │ │ │ ├── kronecker_symbol.rs │ │ │ ├── log_base.rs │ │ │ ├── log_base_power_of_2.rs │ │ │ ├── mod.rs │ │ │ ├── mod_inverse.rs │ │ │ ├── mod_mul.rs │ │ │ ├── mod_op.rs │ │ │ ├── mod_pow.rs │ │ │ ├── mod_power_of_2_pow.rs │ │ │ ├── mod_power_of_2_square.rs │ │ │ ├── mul.rs │ │ │ ├── neg.rs │ │ │ ├── pow.rs │ │ │ ├── primorial.rs │ │ │ ├── root.rs │ │ │ ├── sqrt.rs │ │ │ ├── square.rs │ │ │ └── sub.rs │ │ ├── comparison/ │ │ │ ├── cmp.rs │ │ │ ├── mod.rs │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ └── partial_eq_primitive_int.rs │ │ ├── conversion/ │ │ │ ├── mod.rs │ │ │ └── string/ │ │ │ ├── from_string.rs │ │ │ ├── mod.rs │ │ │ └── to_string.rs │ │ ├── logic/ │ │ │ ├── and.rs │ │ │ ├── count_ones.rs │ │ │ ├── from_bits.rs │ │ │ ├── get_bit.rs │ │ │ ├── hamming_distance.rs │ │ │ ├── index_of_next_false_bit.rs │ │ │ ├── index_of_next_true_bit.rs │ │ │ ├── mod.rs │ │ │ ├── or.rs │ │ │ ├── set_bit.rs │ │ │ ├── to_bits.rs │ │ │ ├── trailing_zeros.rs │ │ │ └── xor.rs │ │ ├── mod.rs │ │ └── random/ │ │ └── mod.rs │ └── tests/ │ ├── integer/ │ │ ├── arithmetic/ │ │ │ ├── abs.rs │ │ │ ├── abs_diff.rs │ │ │ ├── add.rs │ │ │ ├── add_mul.rs │ │ │ ├── binomial_coefficient.rs │ │ │ ├── div.rs │ │ │ ├── div_exact.rs │ │ │ ├── div_mod.rs │ │ │ ├── div_round.rs │ │ │ ├── divisible_by.rs │ │ │ ├── divisible_by_power_of_2.rs │ │ │ ├── eq_mod.rs │ │ │ ├── eq_mod_power_of_2.rs │ │ │ ├── extended_gcd.rs │ │ │ ├── kronecker_symbol.rs │ │ │ ├── mod_op.rs │ │ │ ├── mod_power_of_2.rs │ │ │ ├── mul.rs │ │ │ ├── neg.rs │ │ │ ├── parity.rs │ │ │ ├── pow.rs │ │ │ ├── power_of_2.rs │ │ │ ├── root.rs │ │ │ ├── round_to_multiple.rs │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ ├── shl.rs │ │ │ ├── shl_round.rs │ │ │ ├── shr.rs │ │ │ ├── shr_round.rs │ │ │ ├── sign.rs │ │ │ ├── sqrt.rs │ │ │ ├── square.rs │ │ │ ├── sub.rs │ │ │ └── sub_mul.rs │ │ ├── basic/ │ │ │ ├── constants.rs │ │ │ ├── default.rs │ │ │ ├── from_sign_and_abs.rs │ │ │ ├── named.rs │ │ │ └── size.rs │ │ ├── comparison/ │ │ │ ├── cmp.rs │ │ │ ├── cmp_abs.rs │ │ │ ├── eq.rs │ │ │ ├── eq_abs.rs │ │ │ ├── eq_abs_natural.rs │ │ │ ├── eq_abs_primitive_float.rs │ │ │ ├── eq_abs_primitive_int.rs │ │ │ ├── hash.rs │ │ │ ├── partial_cmp_abs_natural.rs │ │ │ ├── partial_cmp_abs_primitive_float.rs │ │ │ ├── partial_cmp_abs_primitive_int.rs │ │ │ ├── partial_cmp_natural.rs │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ ├── partial_eq_natural.rs │ │ │ ├── partial_eq_primitive_float.rs │ │ │ └── partial_eq_primitive_int.rs │ │ ├── conversion/ │ │ │ ├── clone.rs │ │ │ ├── from_bool.rs │ │ │ ├── from_natural.rs │ │ │ ├── from_primitive_float.rs │ │ │ ├── from_primitive_int.rs │ │ │ ├── from_twos_complement_limbs.rs │ │ │ ├── is_integer.rs │ │ │ ├── natural_from_integer.rs │ │ │ ├── primitive_float_from_integer.rs │ │ │ ├── primitive_int_from_integer.rs │ │ │ ├── serde.rs │ │ │ ├── string/ │ │ │ │ ├── from_sci_string.rs │ │ │ │ ├── from_string.rs │ │ │ │ ├── to_sci.rs │ │ │ │ └── to_string.rs │ │ │ └── to_twos_complement_limbs.rs │ │ ├── exhaustive/ │ │ │ ├── exhaustive_integer_inclusive_range.rs │ │ │ ├── exhaustive_integer_range.rs │ │ │ ├── exhaustive_integer_range_to_infinity.rs │ │ │ ├── exhaustive_integer_range_to_negative_infinity.rs │ │ │ ├── exhaustive_integers.rs │ │ │ ├── exhaustive_natural_integers.rs │ │ │ ├── exhaustive_negative_integers.rs │ │ │ ├── exhaustive_nonzero_integers.rs │ │ │ ├── exhaustive_positive_integers.rs │ │ │ ├── integer_decreasing_range_to_negative_infinity.rs │ │ │ ├── integer_increasing_inclusive_range.rs │ │ │ ├── integer_increasing_range.rs │ │ │ └── integer_increasing_range_to_infinity.rs │ │ ├── logic/ │ │ │ ├── and.rs │ │ │ ├── assign_bit.rs │ │ │ ├── assign_bits.rs │ │ │ ├── bits.rs │ │ │ ├── checked_count_ones.rs │ │ │ ├── checked_count_zeros.rs │ │ │ ├── checked_hamming_distance.rs │ │ │ ├── clear_bit.rs │ │ │ ├── flip_bit.rs │ │ │ ├── from_bits.rs │ │ │ ├── get_bit.rs │ │ │ ├── get_bits.rs │ │ │ ├── index_of_next_false_bit.rs │ │ │ ├── index_of_next_true_bit.rs │ │ │ ├── low_mask.rs │ │ │ ├── not.rs │ │ │ ├── or.rs │ │ │ ├── set_bit.rs │ │ │ ├── significant_bits.rs │ │ │ ├── to_bits.rs │ │ │ ├── trailing_zeros.rs │ │ │ └── xor.rs │ │ └── random/ │ │ ├── get_random_integer_from_range_to_infinity.rs │ │ ├── get_random_integer_from_range_to_negative_infinity.rs │ │ ├── get_striped_random_integer_from_inclusive_range.rs │ │ ├── get_striped_random_integer_from_range.rs │ │ ├── get_striped_random_integer_from_range_to_infinity.rs │ │ ├── get_striped_random_integer_from_range_to_negative_infinity.rs │ │ ├── get_uniform_random_integer_from_inclusive_range.rs │ │ ├── get_uniform_random_integer_from_range.rs │ │ ├── random_integer_inclusive_range.rs │ │ ├── random_integer_range.rs │ │ ├── random_integer_range_to_infinity.rs │ │ ├── random_integer_range_to_negative_infinity.rs │ │ ├── random_integers.rs │ │ ├── random_natural_integers.rs │ │ ├── random_negative_integers.rs │ │ ├── random_nonzero_integers.rs │ │ ├── random_positive_integers.rs │ │ ├── striped_random_integer_inclusive_range.rs │ │ ├── striped_random_integer_range.rs │ │ ├── striped_random_integer_range_to_infinity.rs │ │ ├── striped_random_integer_range_to_negative_infinity.rs │ │ ├── striped_random_integers.rs │ │ ├── striped_random_natural_integers.rs │ │ ├── striped_random_negative_integers.rs │ │ ├── striped_random_nonzero_integers.rs │ │ ├── striped_random_positive_integers.rs │ │ ├── uniform_random_integer_inclusive_range.rs │ │ └── uniform_random_integer_range.rs │ ├── lib.rs │ └── natural/ │ ├── arithmetic/ │ │ ├── abs_diff.rs │ │ ├── add.rs │ │ ├── add_mul.rs │ │ ├── binomial_coefficient.rs │ │ ├── checked_sub.rs │ │ ├── checked_sub_mul.rs │ │ ├── coprime_with.rs │ │ ├── div.rs │ │ ├── div_exact.rs │ │ ├── div_mod.rs │ │ ├── div_round.rs │ │ ├── divisible_by.rs │ │ ├── divisible_by_power_of_2.rs │ │ ├── eq_mod.rs │ │ ├── eq_mod_power_of_2.rs │ │ ├── extended_gcd.rs │ │ ├── factorial.rs │ │ ├── gcd.rs │ │ ├── is_power_of_2.rs │ │ ├── kronecker_symbol.rs │ │ ├── lcm.rs │ │ ├── log_base.rs │ │ ├── log_base_2.rs │ │ ├── log_base_power_of_2.rs │ │ ├── mod_add.rs │ │ ├── mod_inverse.rs │ │ ├── mod_is_reduced.rs │ │ ├── mod_mul.rs │ │ ├── mod_neg.rs │ │ ├── mod_op.rs │ │ ├── mod_pow.rs │ │ ├── mod_power_of_2.rs │ │ ├── mod_power_of_2_add.rs │ │ ├── mod_power_of_2_inverse.rs │ │ ├── mod_power_of_2_is_reduced.rs │ │ ├── mod_power_of_2_mul.rs │ │ ├── mod_power_of_2_neg.rs │ │ ├── mod_power_of_2_pow.rs │ │ ├── mod_power_of_2_shl.rs │ │ ├── mod_power_of_2_shr.rs │ │ ├── mod_power_of_2_square.rs │ │ ├── mod_power_of_2_sub.rs │ │ ├── mod_shl.rs │ │ ├── mod_shr.rs │ │ ├── mod_square.rs │ │ ├── mod_sub.rs │ │ ├── mul.rs │ │ ├── neg.rs │ │ ├── next_power_of_2.rs │ │ ├── parity.rs │ │ ├── pow.rs │ │ ├── power_of_2.rs │ │ ├── primorial.rs │ │ ├── root.rs │ │ ├── round_to_multiple.rs │ │ ├── round_to_multiple_of_power_of_2.rs │ │ ├── saturating_sub.rs │ │ ├── saturating_sub_mul.rs │ │ ├── shl.rs │ │ ├── shl_round.rs │ │ ├── shr.rs │ │ ├── shr_round.rs │ │ ├── sign.rs │ │ ├── sqrt.rs │ │ ├── square.rs │ │ ├── sub.rs │ │ └── sub_mul.rs │ ├── basic/ │ │ ├── constants.rs │ │ ├── default.rs │ │ ├── named.rs │ │ └── size.rs │ ├── comparison/ │ │ ├── cmp.rs │ │ ├── eq.rs │ │ ├── eq_abs_primitive_float.rs │ │ ├── eq_abs_primitive_int.rs │ │ ├── hash.rs │ │ ├── partial_cmp_abs_primitive_float.rs │ │ ├── partial_cmp_abs_primitive_int.rs │ │ ├── partial_cmp_primitive_float.rs │ │ ├── partial_cmp_primitive_int.rs │ │ ├── partial_eq_primitive_float.rs │ │ └── partial_eq_primitive_int.rs │ ├── conversion/ │ │ ├── clone.rs │ │ ├── digits/ │ │ │ ├── from_digits.rs │ │ │ ├── from_power_of_2_digits.rs │ │ │ ├── power_of_2_digits.rs │ │ │ ├── to_digits.rs │ │ │ └── to_power_of_2_digits.rs │ │ ├── from_bool.rs │ │ ├── from_limbs.rs │ │ ├── from_primitive_float.rs │ │ ├── from_primitive_int.rs │ │ ├── is_integer.rs │ │ ├── mantissa_and_exponent/ │ │ │ ├── integer_mantissa_and_exponent.rs │ │ │ └── sci_mantissa_and_exponent.rs │ │ ├── primitive_float_from_natural.rs │ │ ├── primitive_int_from_natural.rs │ │ ├── serde.rs │ │ ├── string/ │ │ │ ├── from_sci_string.rs │ │ │ ├── from_string.rs │ │ │ ├── to_sci.rs │ │ │ └── to_string.rs │ │ └── to_limbs.rs │ ├── exhaustive/ │ │ ├── exhaustive_natural_inclusive_range.rs │ │ ├── exhaustive_natural_range.rs │ │ ├── exhaustive_natural_range_to_infinity.rs │ │ ├── exhaustive_naturals.rs │ │ └── exhaustive_positive_naturals.rs │ ├── factorization/ │ │ ├── is_power.rs │ │ ├── is_square.rs │ │ └── primes.rs │ ├── logic/ │ │ ├── and.rs │ │ ├── assign_bit.rs │ │ ├── assign_bits.rs │ │ ├── bits.rs │ │ ├── clear_bit.rs │ │ ├── count_ones.rs │ │ ├── flip_bit.rs │ │ ├── from_bits.rs │ │ ├── get_bit.rs │ │ ├── get_bits.rs │ │ ├── hamming_distance.rs │ │ ├── index_of_next_false_bit.rs │ │ ├── index_of_next_true_bit.rs │ │ ├── limb_count.rs │ │ ├── low_mask.rs │ │ ├── not.rs │ │ ├── or.rs │ │ ├── set_bit.rs │ │ ├── significant_bits.rs │ │ ├── to_bits.rs │ │ ├── trailing_zeros.rs │ │ └── xor.rs │ └── random/ │ ├── get_random_natural_less_than.rs │ ├── get_random_natural_with_bits.rs │ ├── get_random_natural_with_up_to_bits.rs │ ├── get_striped_random_natural_from_inclusive_range.rs │ ├── get_striped_random_natural_from_range.rs │ ├── get_striped_random_natural_with_bits.rs │ ├── get_striped_random_natural_with_up_to_bits.rs │ ├── random_natural_inclusive_range.rs │ ├── random_natural_range.rs │ ├── random_natural_range_to_infinity.rs │ ├── random_naturals.rs │ ├── random_naturals_less_than.rs │ ├── random_positive_naturals.rs │ ├── striped_random_natural_inclusive_range.rs │ ├── striped_random_natural_range.rs │ ├── striped_random_natural_range_to_infinity.rs │ ├── striped_random_naturals.rs │ ├── striped_random_positive_naturals.rs │ ├── uniform_random_natural_inclusive_range.rs │ └── uniform_random_natural_range.rs ├── malachite-q/ │ ├── .gitignore │ ├── Cargo.toml │ ├── README.md │ ├── katex-header.html │ ├── rustfmt.toml │ ├── src/ │ │ ├── arithmetic/ │ │ │ ├── abs.rs │ │ │ ├── abs_diff.rs │ │ │ ├── add.rs │ │ │ ├── approximate.rs │ │ │ ├── ceiling.rs │ │ │ ├── denominators_in_closed_interval.rs │ │ │ ├── div.rs │ │ │ ├── floor.rs │ │ │ ├── is_power_of_2.rs │ │ │ ├── log_base.rs │ │ │ ├── log_base_2.rs │ │ │ ├── log_base_power_of_2.rs │ │ │ ├── mod.rs │ │ │ ├── mod_op.rs │ │ │ ├── mul.rs │ │ │ ├── neg.rs │ │ │ ├── next_power_of_2.rs │ │ │ ├── pow.rs │ │ │ ├── power_of_2.rs │ │ │ ├── reciprocal.rs │ │ │ ├── root.rs │ │ │ ├── round_to_multiple.rs │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ ├── shl.rs │ │ │ ├── shr.rs │ │ │ ├── sign.rs │ │ │ ├── simplest_rational_in_interval.rs │ │ │ ├── sqrt.rs │ │ │ ├── square.rs │ │ │ ├── sub.rs │ │ │ └── traits.rs │ │ ├── bin.rs │ │ ├── bin_util/ │ │ │ └── demo_and_bench/ │ │ │ ├── arithmetic/ │ │ │ │ ├── abs.rs │ │ │ │ ├── abs_diff.rs │ │ │ │ ├── add.rs │ │ │ │ ├── approximate.rs │ │ │ │ ├── ceiling.rs │ │ │ │ ├── denominators_in_closed_interval.rs │ │ │ │ ├── div.rs │ │ │ │ ├── floor.rs │ │ │ │ ├── is_power_of_2.rs │ │ │ │ ├── log_base.rs │ │ │ │ ├── log_base_2.rs │ │ │ │ ├── log_base_power_of_2.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── mod_op.rs │ │ │ │ ├── mul.rs │ │ │ │ ├── neg.rs │ │ │ │ ├── next_power_of_2.rs │ │ │ │ ├── pow.rs │ │ │ │ ├── power_of_2.rs │ │ │ │ ├── reciprocal.rs │ │ │ │ ├── root.rs │ │ │ │ ├── round_to_multiple.rs │ │ │ │ ├── round_to_multiple_of_power_of_2.rs │ │ │ │ ├── shl.rs │ │ │ │ ├── shr.rs │ │ │ │ ├── sign.rs │ │ │ │ ├── simplest_rational_in_interval.rs │ │ │ │ ├── sqrt.rs │ │ │ │ ├── square.rs │ │ │ │ └── sub.rs │ │ │ ├── basic/ │ │ │ │ ├── mod.rs │ │ │ │ └── significant_bits.rs │ │ │ ├── comparison/ │ │ │ │ ├── cmp.rs │ │ │ │ ├── cmp_abs.rs │ │ │ │ ├── eq.rs │ │ │ │ ├── eq_abs.rs │ │ │ │ ├── eq_abs_integer.rs │ │ │ │ ├── eq_abs_natural.rs │ │ │ │ ├── eq_abs_primitive_float.rs │ │ │ │ ├── eq_abs_primitive_int.rs │ │ │ │ ├── hash.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── partial_cmp_abs_integer.rs │ │ │ │ ├── partial_cmp_abs_natural.rs │ │ │ │ ├── partial_cmp_abs_primitive_float.rs │ │ │ │ ├── partial_cmp_abs_primitive_int.rs │ │ │ │ ├── partial_cmp_integer.rs │ │ │ │ ├── partial_cmp_natural.rs │ │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ │ ├── partial_eq_integer.rs │ │ │ │ ├── partial_eq_natural.rs │ │ │ │ ├── partial_eq_primitive_float.rs │ │ │ │ └── partial_eq_primitive_int.rs │ │ │ ├── conversion/ │ │ │ │ ├── clone.rs │ │ │ │ ├── continued_fraction/ │ │ │ │ │ ├── convergents.rs │ │ │ │ │ ├── from_continued_fraction.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ └── to_continued_fraction.rs │ │ │ │ ├── digits/ │ │ │ │ │ ├── from_digits.rs │ │ │ │ │ ├── from_power_of_2_digits.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── to_digits.rs │ │ │ │ │ └── to_power_of_2_digits.rs │ │ │ │ ├── from_bool.rs │ │ │ │ ├── from_float_simplest.rs │ │ │ │ ├── from_integer.rs │ │ │ │ ├── from_natural.rs │ │ │ │ ├── from_numerator_and_denominator.rs │ │ │ │ ├── from_primitive_float.rs │ │ │ │ ├── from_primitive_int.rs │ │ │ │ ├── integer_from_rational.rs │ │ │ │ ├── is_integer.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── mutate_numerator_or_denominator.rs │ │ │ │ ├── natural_from_rational.rs │ │ │ │ ├── primitive_float_from_rational.rs │ │ │ │ ├── primitive_int_from_rational.rs │ │ │ │ ├── sci_mantissa_and_exponent.rs │ │ │ │ ├── serde.rs │ │ │ │ ├── string/ │ │ │ │ │ ├── from_sci_string.rs │ │ │ │ │ ├── from_string.rs │ │ │ │ │ ├── mod.rs │ │ │ │ │ ├── to_sci.rs │ │ │ │ │ └── to_string.rs │ │ │ │ └── to_numerator_or_denominator.rs │ │ │ └── mod.rs │ │ ├── comparison/ │ │ │ ├── cmp.rs │ │ │ ├── cmp_abs.rs │ │ │ ├── eq_abs.rs │ │ │ ├── eq_abs_integer.rs │ │ │ ├── eq_abs_natural.rs │ │ │ ├── eq_abs_primitive_float.rs │ │ │ ├── eq_abs_primitive_int.rs │ │ │ ├── mod.rs │ │ │ ├── partial_cmp_abs_integer.rs │ │ │ ├── partial_cmp_abs_natural.rs │ │ │ ├── partial_cmp_abs_primitive_float.rs │ │ │ ├── partial_cmp_abs_primitive_int.rs │ │ │ ├── partial_cmp_integer.rs │ │ │ ├── partial_cmp_natural.rs │ │ │ ├── partial_cmp_primitive_float.rs │ │ │ ├── partial_cmp_primitive_int.rs │ │ │ ├── partial_eq_integer.rs │ │ │ ├── partial_eq_natural.rs │ │ │ ├── partial_eq_primitive_float.rs │ │ │ └── partial_eq_primitive_int.rs │ │ ├── conversion/ │ │ │ ├── continued_fraction/ │ │ │ │ ├── convergents.rs │ │ │ │ ├── from_continued_fraction.rs │ │ │ │ ├── mod.rs │ │ │ │ └── to_continued_fraction.rs │ │ │ ├── digits/ │ │ │ │ ├── digits.rs │ │ │ │ ├── from_digits.rs │ │ │ │ ├── from_power_of_2_digits.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── power_of_2_digits.rs │ │ │ │ ├── to_digits.rs │ │ │ │ └── to_power_of_2_digits.rs │ │ │ ├── from_bool.rs │ │ │ ├── from_float_simplest.rs │ │ │ ├── from_integer.rs │ │ │ ├── from_natural.rs │ │ │ ├── from_numerator_and_denominator.rs │ │ │ ├── from_primitive_float.rs │ │ │ ├── from_primitive_int.rs │ │ │ ├── integer_from_rational.rs │ │ │ ├── is_integer.rs │ │ │ ├── mantissa_and_exponent.rs │ │ │ ├── mod.rs │ │ │ ├── mutate_numerator_and_denominator.rs │ │ │ ├── natural_from_rational.rs │ │ │ ├── primitive_float_from_rational.rs │ │ │ ├── primitive_int_from_rational.rs │ │ │ ├── string/ │ │ │ │ ├── from_sci_string.rs │ │ │ │ ├── from_string.rs │ │ │ │ ├── mod.rs │ │ │ │ ├── to_sci.rs │ │ │ │ └── to_string.rs │ │ │ ├── to_numerator_and_denominator.rs │ │ │ └── traits.rs │ │ ├── exhaustive/ │ │ │ └── mod.rs │ │ ├── lib.rs │ │ ├── random/ │ │ │ └── mod.rs │ │ └── test_util/ │ │ ├── arithmetic/ │ │ │ ├── add.rs │ │ │ ├── approximate.rs │ │ │ ├── div.rs │ │ │ ├── mod.rs │ │ │ ├── mod_op.rs │ │ │ ├── mul.rs │ │ │ ├── sign.rs │ │ │ ├── simplest_rational_in_interval.rs │ │ │ └── sub.rs │ │ ├── bench/ │ │ │ ├── bucketers.rs │ │ │ └── mod.rs │ │ ├── common/ │ │ │ └── mod.rs │ │ ├── conversion/ │ │ │ ├── continued_fraction/ │ │ │ │ ├── convergents.rs │ │ │ │ ├── from_continued_fraction.rs │ │ │ │ └── mod.rs │ │ │ └── mod.rs │ │ ├── extra_variadic/ │ │ │ └── mod.rs │ │ ├── generators/ │ │ │ ├── common.rs │ │ │ ├── exhaustive.rs │ │ │ ├── mod.rs │ │ │ ├── random.rs │ │ │ └── special_random.rs │ │ ├── mod.rs │ │ └── random/ │ │ └── mod.rs │ └── tests/ │ ├── arithmetic/ │ │ ├── abs.rs │ │ ├── abs_diff.rs │ │ ├── add.rs │ │ ├── approximate.rs │ │ ├── ceiling.rs │ │ ├── denominators_in_closed_interval.rs │ │ ├── div.rs │ │ ├── floor.rs │ │ ├── is_power_of_2.rs │ │ ├── log_base.rs │ │ ├── log_base_2.rs │ │ ├── log_base_power_of_2.rs │ │ ├── mod_op.rs │ │ ├── mul.rs │ │ ├── neg.rs │ │ ├── next_power_of_2.rs │ │ ├── pow.rs │ │ ├── power_of_2.rs │ │ ├── reciprocal.rs │ │ ├── root.rs │ │ ├── round_to_multiple.rs │ │ ├── round_to_multiple_of_power_of_2.rs │ │ ├── shl.rs │ │ ├── shr.rs │ │ ├── sign.rs │ │ ├── simplest_rational_in_interval.rs │ │ ├── sqrt.rs │ │ ├── square.rs │ │ └── sub.rs │ ├── basic/ │ │ ├── constants.rs │ │ ├── default.rs │ │ ├── named.rs │ │ ├── significant_bits.rs │ │ └── size.rs │ ├── comparison/ │ │ ├── cmp.rs │ │ ├── cmp_abs.rs │ │ ├── eq.rs │ │ ├── eq_abs.rs │ │ ├── eq_abs_integer.rs │ │ ├── eq_abs_natural.rs │ │ ├── eq_abs_primitive_float.rs │ │ ├── eq_abs_primitive_int.rs │ │ ├── hash.rs │ │ ├── partial_cmp_abs_integer.rs │ │ ├── partial_cmp_abs_natural.rs │ │ ├── partial_cmp_abs_primitive_float.rs │ │ ├── partial_cmp_abs_primitive_int.rs │ │ ├── partial_cmp_integer.rs │ │ ├── partial_cmp_natural.rs │ │ ├── partial_cmp_primitive_float.rs │ │ ├── partial_cmp_primitive_int.rs │ │ ├── partial_eq_integer.rs │ │ ├── partial_eq_natural.rs │ │ ├── partial_eq_primitive_float.rs │ │ └── partial_eq_primitive_int.rs │ ├── conversion/ │ │ ├── clone.rs │ │ ├── continued_fraction/ │ │ │ ├── convergents.rs │ │ │ ├── from_continued_fraction.rs │ │ │ └── to_continued_fraction.rs │ │ ├── digits/ │ │ │ ├── digits.rs │ │ │ ├── from_digits.rs │ │ │ ├── from_power_of_2_digits.rs │ │ │ ├── power_of_2_digits.rs │ │ │ ├── to_digits.rs │ │ │ └── to_power_of_2_digits.rs │ │ ├── from_bool.rs │ │ ├── from_float_simplest.rs │ │ ├── from_integer.rs │ │ ├── from_natural.rs │ │ ├── from_numerator_and_denominator.rs │ │ ├── from_primitive_float.rs │ │ ├── from_primitive_int.rs │ │ ├── integer_from_rational.rs │ │ ├── is_integer.rs │ │ ├── mutate_numerator_or_denominator.rs │ │ ├── natural_from_rational.rs │ │ ├── primitive_float_from_rational.rs │ │ ├── primitive_int_from_rational.rs │ │ ├── sci_mantissa_and_exponent.rs │ │ ├── serde.rs │ │ ├── string/ │ │ │ ├── from_sci_string.rs │ │ │ ├── from_string.rs │ │ │ ├── to_sci.rs │ │ │ └── to_string.rs │ │ └── to_numerator_or_denominator.rs │ ├── exhaustive/ │ │ ├── exhaustive_negative_rationals.rs │ │ ├── exhaustive_non_negative_rationals.rs │ │ ├── exhaustive_nonzero_rationals.rs │ │ ├── exhaustive_positive_rationals.rs │ │ ├── exhaustive_rational_inclusive_range.rs │ │ ├── exhaustive_rational_range.rs │ │ ├── exhaustive_rational_range_to_infinity.rs │ │ ├── exhaustive_rational_range_to_negative_infinity.rs │ │ ├── exhaustive_rationals.rs │ │ ├── exhaustive_rationals_with_denominator_inclusive_range.rs │ │ ├── exhaustive_rationals_with_denominator_range.rs │ │ ├── exhaustive_rationals_with_denominator_range_to_infinity.rs │ │ └── exhaustive_rationals_with_denominator_range_to_negative_infinity.rs │ ├── lib.rs │ └── random/ │ ├── random_negative_rationals.rs │ ├── random_non_negative_rationals.rs │ ├── random_nonzero_rationals.rs │ ├── random_positive_rationals.rs │ ├── random_rational_inclusive_range.rs │ ├── random_rational_range.rs │ ├── random_rational_range_to_infinity.rs │ ├── random_rational_range_to_negative_infinity.rs │ ├── random_rational_with_denominator_inclusive_range.rs │ ├── random_rational_with_denominator_range.rs │ ├── random_rational_with_denominator_range_to_infinity.rs │ ├── random_rational_with_denominator_range_to_negative_infinity.rs │ ├── random_rationals.rs │ ├── striped_random_negative_rationals.rs │ ├── striped_random_non_negative_rationals.rs │ ├── striped_random_nonzero_rationals.rs │ ├── striped_random_positive_rationals.rs │ ├── striped_random_rational_range_to_infinity.rs │ ├── striped_random_rational_range_to_negative_infinity.rs │ └── striped_random_rationals.rs ├── rundoc.sh └── superfmt.sh
Showing preview only (3,076K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (27002 symbols across 2470 files)
FILE: additional-lints.py
function lint (line 63) | def lint(filename):
FILE: find_replace.py
function search_replace (line 4) | def search_replace(filename, old, new):
FILE: malachite-base/src/bin.rs
function main (line 85) | fn main() {
function main (line 112) | const fn main() {}
FILE: malachite-base/src/bin_util/demo_and_bench/bools/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/bools/not_assign.rs
function register (line 14) | pub(crate) fn register(runner: &mut Runner) {
function demo_bool_not_assign (line 18) | fn demo_bool_not_assign(gm: GenMode, config: &GenConfig, limit: usize) {
FILE: malachite-base/src/bin_util/demo_and_bench/chars/crement/char_to_contiguous_range.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_char_to_contiguous_range (line 21) | fn demo_char_to_contiguous_range(gm: GenMode, config: &GenConfig, limit:...
function benchmark_char_to_contiguous_range (line 31) | fn benchmark_char_to_contiguous_range(
FILE: malachite-base/src/bin_util/demo_and_bench/chars/crement/contiguous_range_to_char.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_contiguous_range_to_char (line 21) | fn demo_contiguous_range_to_char(gm: GenMode, config: &GenConfig, limit:...
function benchmark_contiguous_range_to_char (line 31) | fn benchmark_contiguous_range_to_char(
FILE: malachite-base/src/bin_util/demo_and_bench/chars/crement/crement.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_increment_char (line 23) | fn demo_increment_char(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_decrement_char (line 31) | fn demo_decrement_char(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_increment_char (line 39) | fn benchmark_increment_char(gm: GenMode, config: &GenConfig, limit: usiz...
function benchmark_decrement_char (line 52) | fn benchmark_decrement_char(gm: GenMode, config: &GenConfig, limit: usiz...
FILE: malachite-base/src/bin_util/demo_and_bench/chars/crement/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/chars/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/comparison/macros.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_max_1 (line 34) | fn demo_max_1(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_max_2 (line 40) | fn demo_max_2(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_max_3 (line 46) | fn demo_max_3(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_min_1 (line 55) | fn demo_min_1(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_min_2 (line 61) | fn demo_min_2(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_min_3 (line 67) | fn demo_min_3(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_max_1 (line 76) | fn benchmark_max_1(gm: GenMode, config: &GenConfig, limit: usize, file_n...
function benchmark_max_2 (line 89) | fn benchmark_max_2(gm: GenMode, config: &GenConfig, limit: usize, file_n...
function benchmark_max_3 (line 102) | fn benchmark_max_3(gm: GenMode, config: &GenConfig, limit: usize, file_n...
function benchmark_min_1 (line 115) | fn benchmark_min_1(gm: GenMode, config: &GenConfig, limit: usize, file_n...
function benchmark_min_2 (line 128) | fn benchmark_min_2(gm: GenMode, config: &GenConfig, limit: usize, file_n...
function benchmark_min_3 (line 141) | fn benchmark_min_3(gm: GenMode, config: &GenConfig, limit: usize, file_n...
FILE: malachite-base/src/bin_util/demo_and_bench/comparison/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/mod.rs
function register (line 75) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/abs.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_abs_assign_signed (line 25) | fn demo_abs_assign_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function demo_abs_assign_primitive_float (line 33) | fn demo_abs_assign_primitive_float<T: PrimitiveFloat>(
function benchmark_abs_assign_signed (line 49) | fn benchmark_abs_assign_signed<T: PrimitiveSigned>(
function benchmark_abs_assign_primitive_float (line 67) | fn benchmark_abs_assign_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/abs_diff.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_abs_diff_assign (line 21) | fn demo_abs_diff_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function benchmark_abs_diff_assign (line 29) | fn benchmark_abs_diff_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/add_mul.rs
function register (line 23) | pub(crate) fn register(runner: &mut Runner) {
function demo_add_mul_unsigned (line 39) | fn demo_add_mul_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_add_mul_signed (line 45) | fn demo_add_mul_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConf...
function demo_add_mul_primitive_float (line 51) | fn demo_add_mul_primitive_float<T: PrimitiveFloat>(gm: GenMode, config: ...
function demo_add_mul_assign_unsigned (line 66) | fn demo_add_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_add_mul_assign_signed (line 78) | fn demo_add_mul_assign_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_add_mul_assign_primitive_float (line 86) | fn demo_add_mul_assign_primitive_float<T: PrimitiveFloat>(
function benchmark_add_mul_unsigned (line 107) | fn benchmark_add_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_add_mul_signed (line 125) | fn benchmark_add_mul_signed<T: PrimitiveSigned>(
function benchmark_add_mul_primitive_float (line 143) | fn benchmark_add_mul_primitive_float<T: PrimitiveFloat>(
function benchmark_add_mul_assign_unsigned (line 161) | fn benchmark_add_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_add_mul_assign_signed (line 179) | fn benchmark_add_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_add_mul_assign_primitive_float (line 197) | fn benchmark_add_mul_assign_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/arithmetic_checked_shl.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_arithmetic_checked_shl_unsigned_unsigned (line 32) | fn demo_arithmetic_checked_shl_unsigned_unsigned<
function demo_arithmetic_checked_shl_unsigned_signed (line 53) | fn demo_arithmetic_checked_shl_unsigned_signed<
function demo_arithmetic_checked_shl_signed_unsigned (line 74) | fn demo_arithmetic_checked_shl_signed_unsigned<
function demo_arithmetic_checked_shl_signed_signed (line 95) | fn demo_arithmetic_checked_shl_signed_signed<
function benchmark_arithmetic_checked_shl_unsigned_unsigned (line 113) | fn benchmark_arithmetic_checked_shl_unsigned_unsigned<
function benchmark_arithmetic_checked_shl_unsigned_signed (line 138) | fn benchmark_arithmetic_checked_shl_unsigned_signed<
function benchmark_arithmetic_checked_shl_signed_unsigned (line 163) | fn benchmark_arithmetic_checked_shl_signed_unsigned<
function benchmark_arithmetic_checked_shl_signed_signed (line 188) | fn benchmark_arithmetic_checked_shl_signed_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/arithmetic_checked_shr.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_arithmetic_checked_shr_unsigned_signed (line 27) | fn demo_arithmetic_checked_shr_unsigned_signed<
function demo_arithmetic_checked_shr_signed_signed (line 48) | fn demo_arithmetic_checked_shr_signed_signed<
function benchmark_arithmetic_checked_shr_unsigned_signed (line 66) | fn benchmark_arithmetic_checked_shr_unsigned_signed<
function benchmark_arithmetic_checked_shr_signed_signed (line 91) | fn benchmark_arithmetic_checked_shr_signed_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/binomial_coefficient.rs
function register (line 23) | pub(crate) fn register(runner: &mut Runner) {
function demo_binomial_coefficient_unsigned (line 35) | fn demo_binomial_coefficient_unsigned<T: PrimitiveUnsigned>(
function demo_binomial_coefficient_signed (line 45) | fn demo_binomial_coefficient_signed<T: PrimitiveSigned>(
function demo_checked_binomial_coefficient_unsigned (line 55) | fn demo_checked_binomial_coefficient_unsigned<T: PrimitiveUnsigned>(
function demo_checked_binomial_coefficient_signed (line 70) | fn demo_checked_binomial_coefficient_signed<T: PrimitiveSigned>(
function benchmark_binomial_coefficient_unsigned (line 85) | fn benchmark_binomial_coefficient_unsigned<T: PrimitiveUnsigned>(
function benchmark_binomial_coefficient_signed (line 112) | fn benchmark_binomial_coefficient_signed<T: PrimitiveSigned>(
function benchmark_checked_binomial_coefficient_unsigned (line 140) | fn benchmark_checked_binomial_coefficient_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_binomial_coefficient_signed (line 167) | fn benchmark_checked_binomial_coefficient_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/ceiling.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_ceiling_assign (line 22) | fn demo_ceiling_assign<T: PrimitiveFloat>(gm: GenMode, config: &GenConfi...
function benchmark_ceiling_assign (line 34) | fn benchmark_ceiling_assign<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/checked_add_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_checked_add_mul_unsigned (line 25) | fn demo_checked_add_mul_unsigned<T: PrimitiveUnsigned>(
function demo_checked_add_mul_signed (line 44) | fn demo_checked_add_mul_signed<T: PrimitiveSigned>(gm: GenMode, config: ...
function benchmark_checked_add_mul_unsigned (line 56) | fn benchmark_checked_add_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_add_mul_signed (line 76) | fn benchmark_checked_add_mul_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/checked_square.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_checked_square_unsigned (line 24) | fn demo_checked_square_unsigned<T: PrimitiveUnsigned>(
function demo_checked_square_signed (line 34) | fn demo_checked_square_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function benchmark_checked_square_unsigned (line 40) | fn benchmark_checked_square_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_square_signed (line 58) | fn benchmark_checked_square_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/checked_sub_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_checked_sub_mul_unsigned (line 25) | fn demo_checked_sub_mul_unsigned<T: PrimitiveUnsigned>(
function demo_checked_sub_mul_signed (line 44) | fn demo_checked_sub_mul_signed<T: PrimitiveSigned>(gm: GenMode, config: ...
function benchmark_checked_sub_mul_unsigned (line 56) | fn benchmark_checked_sub_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_sub_mul_signed (line 76) | fn benchmark_checked_sub_mul_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/coprime_with.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_coprime_with (line 24) | fn demo_coprime_with<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConf...
function benchmark_coprime_with_algorithms (line 35) | fn benchmark_coprime_with_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/div_exact.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_div_exact_unsigned (line 29) | fn demo_div_exact_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_div_exact_signed (line 35) | fn demo_div_exact_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenCo...
function demo_div_exact_assign_unsigned (line 41) | fn demo_div_exact_assign_unsigned<T: PrimitiveUnsigned>(
function demo_div_exact_assign_signed (line 53) | fn demo_div_exact_assign_signed<T: PrimitiveSigned>(gm: GenMode, config:...
function benchmark_div_exact_unsigned (line 61) | fn benchmark_div_exact_unsigned<T: PrimitiveUnsigned>(
function benchmark_div_exact_signed (line 79) | fn benchmark_div_exact_signed<T: PrimitiveSigned>(
function benchmark_div_exact_assign_unsigned (line 97) | fn benchmark_div_exact_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_div_exact_assign_signed (line 115) | fn benchmark_div_exact_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/div_mod.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_div_mod_unsigned (line 46) | fn demo_div_mod_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_div_mod_signed (line 55) | fn demo_div_mod_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConf...
function demo_div_assign_mod_unsigned (line 61) | fn demo_div_assign_mod_unsigned<T: PrimitiveUnsigned>(
function demo_div_assign_mod_signed (line 76) | fn demo_div_assign_mod_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_div_rem_unsigned (line 84) | fn demo_div_rem_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_div_rem_signed (line 93) | fn demo_div_rem_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConf...
function demo_div_assign_rem_unsigned (line 99) | fn demo_div_assign_rem_unsigned<T: PrimitiveUnsigned>(
function demo_div_assign_rem_signed (line 114) | fn demo_div_assign_rem_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_ceiling_div_neg_mod (line 122) | fn demo_ceiling_div_neg_mod<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_ceiling_div_assign_neg_mod (line 136) | fn demo_ceiling_div_assign_neg_mod<T: PrimitiveUnsigned>(
function demo_ceiling_div_mod (line 151) | fn demo_ceiling_div_mod<T: PrimitiveSigned>(gm: GenMode, config: &GenCon...
function demo_ceiling_div_assign_mod (line 162) | fn demo_ceiling_div_assign_mod<T: PrimitiveSigned>(gm: GenMode, config: ...
function benchmark_div_mod_unsigned_algorithms (line 171) | fn benchmark_div_mod_unsigned_algorithms<T: PrimitiveUnsigned>(
function benchmark_div_mod_signed_algorithms (line 193) | fn benchmark_div_mod_signed_algorithms<T: PrimitiveSigned>(
function benchmark_div_assign_mod_unsigned (line 216) | fn benchmark_div_assign_mod_unsigned<T: PrimitiveUnsigned>(
function benchmark_div_assign_mod_signed (line 234) | fn benchmark_div_assign_mod_signed<T: PrimitiveSigned>(
function benchmark_div_rem_unsigned_algorithms (line 253) | fn benchmark_div_rem_unsigned_algorithms<T: PrimitiveUnsigned>(
function benchmark_div_rem_signed_algorithms (line 275) | fn benchmark_div_rem_signed_algorithms<T: PrimitiveSigned>(
function benchmark_div_assign_rem_unsigned (line 296) | fn benchmark_div_assign_rem_unsigned<T: PrimitiveUnsigned>(
function benchmark_div_assign_rem_signed (line 314) | fn benchmark_div_assign_rem_signed<T: PrimitiveSigned>(
function benchmark_ceiling_div_neg_mod_algorithms (line 333) | fn benchmark_ceiling_div_neg_mod_algorithms<T: PrimitiveUnsigned>(
function benchmark_ceiling_div_mod_algorithms (line 359) | fn benchmark_ceiling_div_mod_algorithms<T: PrimitiveSigned>(
function benchmark_ceiling_div_assign_neg_mod (line 384) | fn benchmark_ceiling_div_assign_neg_mod<T: PrimitiveUnsigned>(
function benchmark_ceiling_div_assign_mod (line 404) | fn benchmark_ceiling_div_assign_mod<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/div_round.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_div_round_unsigned (line 31) | fn demo_div_round_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_div_round_signed (line 40) | fn demo_div_round_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenCo...
function demo_div_round_assign_unsigned (line 55) | fn demo_div_round_assign_unsigned<T: PrimitiveUnsigned>(
function demo_div_round_assign_signed (line 70) | fn demo_div_round_assign_signed<T: PrimitiveSigned>(gm: GenMode, config:...
function benchmark_div_round_unsigned (line 81) | fn benchmark_div_round_unsigned<T: PrimitiveUnsigned>(
function benchmark_div_round_signed (line 99) | fn benchmark_div_round_signed<T: PrimitiveSigned>(
function benchmark_div_round_assign_unsigned (line 117) | fn benchmark_div_round_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_div_round_assign_signed (line 137) | fn benchmark_div_round_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/divisible_by.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_divisible_by_unsigned (line 25) | fn demo_divisible_by_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_divisible_by_signed (line 35) | fn demo_divisible_by_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function benchmark_divisible_by_unsigned (line 45) | fn benchmark_divisible_by_unsigned<T: PrimitiveUnsigned>(
function benchmark_divisible_by_signed (line 63) | fn benchmark_divisible_by_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/divisible_by_power_of_2.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_divisible_by_power_of_2_unsigned (line 27) | fn demo_divisible_by_power_of_2_unsigned<T: PrimitiveUnsigned>(
function demo_divisible_by_power_of_2_signed (line 44) | fn demo_divisible_by_power_of_2_signed<T: PrimitiveSigned>(
function benchmark_divisible_by_power_of_2_unsigned (line 61) | fn benchmark_divisible_by_power_of_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_divisible_by_power_of_2_signed (line 81) | fn benchmark_divisible_by_power_of_2_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/eq_mod.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_eq_mod_unsigned (line 25) | fn demo_eq_mod_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function demo_eq_mod_signed (line 38) | fn demo_eq_mod_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfi...
function benchmark_eq_mod_unsigned (line 48) | fn benchmark_eq_mod_unsigned<T: PrimitiveUnsigned>(
function benchmark_eq_mod_signed (line 66) | fn benchmark_eq_mod_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/eq_mod_power_of_2.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_eq_mod_power_of_2_unsigned (line 27) | fn demo_eq_mod_power_of_2_unsigned<T: PrimitiveUnsigned>(
function demo_eq_mod_power_of_2_signed (line 44) | fn demo_eq_mod_power_of_2_signed<T: PrimitiveSigned>(
function benchmark_eq_mod_power_of_2_unsigned (line 61) | fn benchmark_eq_mod_power_of_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_eq_mod_power_of_2_signed (line 81) | fn benchmark_eq_mod_power_of_2_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/extended_gcd.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_extended_gcd_unsigned (line 29) | fn demo_extended_gcd_unsigned<
function demo_extended_gcd_signed (line 42) | fn demo_extended_gcd_signed<U: PrimitiveUnsigned, S: ExtendedGcd<Gcd = U...
function benchmark_extended_gcd_algorithms_unsigned (line 52) | fn benchmark_extended_gcd_algorithms_unsigned<
function benchmark_extended_gcd_signed (line 81) | fn benchmark_extended_gcd_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/factorial.rs
function register (line 25) | pub(crate) fn register(runner: &mut Runner) {
function demo_factorial (line 45) | fn demo_factorial<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig,...
function demo_checked_factorial (line 51) | fn demo_checked_factorial<T: PrimitiveUnsigned>(gm: GenMode, config: &Ge...
function demo_double_factorial (line 57) | fn demo_double_factorial<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_checked_double_factorial (line 63) | fn demo_checked_double_factorial<T: PrimitiveUnsigned>(
function demo_multifactorial (line 73) | fn demo_multifactorial<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function demo_checked_multifactorial (line 87) | fn demo_checked_multifactorial<T: PrimitiveUnsigned>(
function demo_subfactorial (line 108) | fn demo_subfactorial<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConf...
function demo_checked_subfactorial (line 114) | fn demo_checked_subfactorial<T: PrimitiveUnsigned>(gm: GenMode, config: ...
function benchmark_factorial_algorithms (line 120) | fn benchmark_factorial_algorithms<T: PrimitiveUnsigned>(
function benchmark_checked_factorial (line 143) | fn benchmark_checked_factorial<T: PrimitiveUnsigned>(
function benchmark_double_factorial_algorithms (line 161) | fn benchmark_double_factorial_algorithms<T: PrimitiveUnsigned>(
function benchmark_checked_double_factorial (line 184) | fn benchmark_checked_double_factorial<T: PrimitiveUnsigned>(
function benchmark_multifactorial_algorithms (line 204) | fn benchmark_multifactorial_algorithms<T: PrimitiveUnsigned>(
function benchmark_checked_multifactorial (line 227) | fn benchmark_checked_multifactorial<T: PrimitiveUnsigned>(
function benchmark_subfactorial_algorithms (line 247) | fn benchmark_subfactorial_algorithms<T: PrimitiveUnsigned>(
function benchmark_checked_subfactorial (line 270) | fn benchmark_checked_subfactorial<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/floor.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_floor_assign (line 22) | fn demo_floor_assign<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig,...
function benchmark_floor_assign (line 34) | fn benchmark_floor_assign<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/gcd.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_gcd (line 25) | fn demo_gcd<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, limit...
function demo_gcd_assign (line 31) | fn demo_gcd_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig...
function benchmark_gcd_algorithms (line 39) | fn benchmark_gcd_algorithms<T: PrimitiveUnsigned>(
function benchmark_gcd_assign (line 63) | fn benchmark_gcd_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/is_power_of_2.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_is_power_of_2 (line 22) | fn demo_is_power_of_2<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig...
function benchmark_is_power_of_2 (line 32) | fn benchmark_is_power_of_2<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/kronecker_symbol.rs
function register (line 32) | pub(crate) fn register(runner: &mut Runner) {
function demo_jacobi_symbol_unsigned_double_fast_1 (line 54) | fn demo_jacobi_symbol_unsigned_double_fast_1<T: PrimitiveUnsigned>(
function demo_jacobi_symbol_unsigned_double_fast_2 (line 74) | fn demo_jacobi_symbol_unsigned_double_fast_2<T: PrimitiveUnsigned>(
function demo_jacobi_symbol_unsigned (line 94) | fn demo_jacobi_symbol_unsigned<T: PrimitiveUnsigned>(
function demo_jacobi_symbol_signed (line 104) | fn demo_jacobi_symbol_signed<
function demo_kronecker_symbol_unsigned (line 117) | fn demo_kronecker_symbol_unsigned<T: PrimitiveUnsigned>(
function demo_kronecker_symbol_signed (line 127) | fn demo_kronecker_symbol_signed<T: PrimitiveSigned>(gm: GenMode, config:...
function benchmark_jacobi_symbol_unsigned_algorithms (line 138) | fn benchmark_jacobi_symbol_unsigned_algorithms<T: PrimitiveUnsigned>(
function benchmark_jacobi_symbol_unsigned_double_algorithms (line 176) | fn benchmark_jacobi_symbol_unsigned_double_algorithms<
function benchmark_jacobi_symbol_signed (line 213) | fn benchmark_jacobi_symbol_signed<
function benchmark_kronecker_symbol_unsigned (line 234) | fn benchmark_kronecker_symbol_unsigned<T: PrimitiveUnsigned>(
function benchmark_kronecker_symbol_signed (line 252) | fn benchmark_kronecker_symbol_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/lcm.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_lcm (line 26) | fn demo_lcm<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, limit...
function demo_lcm_assign (line 32) | fn demo_lcm_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig...
function demo_checked_lcm (line 40) | fn demo_checked_lcm<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfi...
function benchmark_lcm (line 46) | fn benchmark_lcm<T: PrimitiveUnsigned>(
function benchmark_lcm_assign (line 64) | fn benchmark_lcm_assign<T: PrimitiveUnsigned>(
function benchmark_checked_lcm (line 82) | fn benchmark_checked_lcm<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/log_base.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_floor_log_base (line 26) | fn demo_floor_log_base<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function demo_ceiling_log_base (line 35) | fn demo_ceiling_log_base<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_checked_log_base (line 44) | fn demo_checked_log_base<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function benchmark_floor_log_base (line 58) | fn benchmark_floor_log_base<T: PrimitiveUnsigned>(
function benchmark_ceiling_log_base_algorithms (line 78) | fn benchmark_ceiling_log_base_algorithms<T: PrimitiveUnsigned>(
function benchmark_checked_log_base_algorithms (line 103) | fn benchmark_checked_log_base_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/log_base_2.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_floor_log_base_2_unsigned (line 35) | fn demo_floor_log_base_2_unsigned<T: PrimitiveUnsigned>(
function demo_ceiling_log_base_2_unsigned (line 45) | fn demo_ceiling_log_base_2_unsigned<T: PrimitiveUnsigned>(
function demo_checked_log_base_2_unsigned (line 55) | fn demo_checked_log_base_2_unsigned<T: PrimitiveUnsigned>(
function demo_floor_log_base_2_primitive_float (line 65) | fn demo_floor_log_base_2_primitive_float<T: PrimitiveFloat>(
function demo_ceiling_log_base_2_primitive_float (line 82) | fn demo_ceiling_log_base_2_primitive_float<T: PrimitiveFloat>(
function demo_checked_log_base_2_primitive_float (line 99) | fn demo_checked_log_base_2_primitive_float<T: PrimitiveFloat>(
function benchmark_floor_log_base_2_unsigned (line 116) | fn benchmark_floor_log_base_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_ceiling_log_base_2_unsigned (line 134) | fn benchmark_ceiling_log_base_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_log_base_2_unsigned (line 152) | fn benchmark_checked_log_base_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_floor_log_base_2_primitive_float (line 170) | fn benchmark_floor_log_base_2_primitive_float<T: PrimitiveFloat>(
function benchmark_ceiling_log_base_2_primitive_float (line 188) | fn benchmark_ceiling_log_base_2_primitive_float<T: PrimitiveFloat>(
function benchmark_checked_log_base_2_primitive_float (line 206) | fn benchmark_checked_log_base_2_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/log_base_power_of_2.rs
function register (line 23) | pub(crate) fn register(runner: &mut Runner) {
function demo_floor_log_base_power_of_2_unsigned (line 48) | fn demo_floor_log_base_power_of_2_unsigned<T: PrimitiveUnsigned>(
function demo_floor_log_base_power_of_2_primitive_float (line 66) | fn demo_floor_log_base_power_of_2_primitive_float<T: PrimitiveFloat>(
function demo_ceiling_log_base_power_of_2_unsigned (line 84) | fn demo_ceiling_log_base_power_of_2_unsigned<T: PrimitiveUnsigned>(
function demo_ceiling_log_base_power_of_2_primitive_float (line 102) | fn demo_ceiling_log_base_power_of_2_primitive_float<T: PrimitiveFloat>(
function demo_checked_log_base_power_of_2_unsigned (line 120) | fn demo_checked_log_base_power_of_2_unsigned<T: PrimitiveUnsigned>(
function demo_checked_log_base_power_of_2_primitive_float (line 138) | fn demo_checked_log_base_power_of_2_primitive_float<T: PrimitiveFloat>(
function benchmark_floor_log_base_power_of_2_unsigned (line 156) | fn benchmark_floor_log_base_power_of_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_floor_log_base_power_of_2_primitive_float (line 176) | fn benchmark_floor_log_base_power_of_2_primitive_float<T: PrimitiveFloat>(
function benchmark_ceiling_log_base_power_of_2_algorithms_unsigned (line 196) | fn benchmark_ceiling_log_base_power_of_2_algorithms_unsigned<T: Primitiv...
function benchmark_ceiling_log_base_power_of_2_primitive_float (line 221) | fn benchmark_ceiling_log_base_power_of_2_primitive_float<T: PrimitiveFlo...
function benchmark_checked_log_base_power_of_2_unsigned (line 241) | fn benchmark_checked_log_base_power_of_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_log_base_power_of_2_primitive_float (line 261) | fn benchmark_checked_log_base_power_of_2_primitive_float<T: PrimitiveFlo...
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_add.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_add (line 23) | fn demo_mod_add<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, l...
function demo_mod_add_assign (line 32) | fn demo_mod_add_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function benchmark_mod_add (line 43) | fn benchmark_mod_add<T: PrimitiveUnsigned>(
function benchmark_mod_add_assign (line 61) | fn benchmark_mod_add_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_inverse.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_inverse (line 25) | fn demo_mod_inverse<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfi...
function benchmark_mod_inverse_algorithms (line 35) | fn benchmark_mod_inverse_algorithms<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_is_reduced.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_is_reduced (line 21) | fn demo_mod_is_reduced<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function benchmark_mod_is_reduced (line 34) | fn benchmark_mod_is_reduced<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_mul.rs
function register (line 27) | pub(crate) fn register(runner: &mut Runner) {
function demo_limbs_invert_limb_u32 (line 62) | fn demo_limbs_invert_limb_u32(gm: GenMode, config: &GenConfig, limit: us...
function demo_limbs_invert_limb_u64 (line 72) | fn demo_limbs_invert_limb_u64(gm: GenMode, config: &GenConfig, limit: us...
function demo_mod_preinverted_double (line 82) | fn demo_mod_preinverted_double<
function demo_mod_mul (line 105) | fn demo_mod_mul<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, l...
function demo_mod_mul_assign (line 114) | fn demo_mod_mul_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function benchmark_limbs_invert_limb_u32_algorithms (line 125) | fn benchmark_limbs_invert_limb_u32_algorithms(
function benchmark_limbs_invert_limb_u64_algorithms (line 148) | fn benchmark_limbs_invert_limb_u64_algorithms(
function benchmark_mod_preinverted_double_algorithms (line 171) | fn benchmark_mod_preinverted_double_algorithms<
function benchmark_mod_mul_algorithms (line 205) | fn benchmark_mod_mul_algorithms<T: PrimitiveUnsigned>(
function benchmark_mod_mul_algorithms_with_fast (line 226) | fn benchmark_mod_mul_algorithms_with_fast<
function benchmark_mod_mul_assign (line 258) | fn benchmark_mod_mul_assign<T: PrimitiveUnsigned>(
function benchmark_mod_mul_precomputed_algorithms (line 276) | fn benchmark_mod_mul_precomputed_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_neg.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_neg (line 23) | fn demo_mod_neg<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, l...
function demo_mod_neg_assign (line 29) | fn demo_mod_neg_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function benchmark_mod_neg (line 37) | fn benchmark_mod_neg<T: PrimitiveUnsigned>(
function benchmark_mod_neg_assign (line 55) | fn benchmark_mod_neg_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_op.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_unsigned (line 39) | fn demo_mod_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConf...
function demo_mod_signed (line 48) | fn demo_mod_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfig, ...
function demo_mod_assign_unsigned (line 54) | fn demo_mod_assign_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_mod_assign_signed (line 65) | fn demo_mod_assign_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function demo_neg_mod (line 73) | fn demo_neg_mod<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, l...
function demo_neg_mod_assign (line 82) | fn demo_neg_mod_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function demo_ceiling_mod (line 93) | fn demo_ceiling_mod<T: PrimitiveSigned>(gm: GenMode, config: &GenConfig,...
function demo_ceiling_mod_assign (line 99) | fn demo_ceiling_mod_assign<T: PrimitiveSigned>(gm: GenMode, config: &Gen...
function benchmark_mod_unsigned_algorithms (line 108) | fn benchmark_mod_unsigned_algorithms<T: PrimitiveUnsigned>(
function benchmark_mod_signed_algorithms (line 130) | fn benchmark_mod_signed_algorithms<T: PrimitiveSigned>(
function benchmark_mod_assign_unsigned (line 151) | fn benchmark_mod_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_mod_assign_signed (line 169) | fn benchmark_mod_assign_signed<T: PrimitiveSigned>(
function benchmark_neg_mod_algorithms (line 188) | fn benchmark_neg_mod_algorithms<T: PrimitiveUnsigned>(
function benchmark_neg_mod_assign (line 211) | fn benchmark_neg_mod_assign<T: PrimitiveUnsigned>(
function benchmark_ceiling_mod_algorithms (line 230) | fn benchmark_ceiling_mod_algorithms<T: PrimitiveSigned>(
function benchmark_ceiling_mod_assign (line 253) | fn benchmark_ceiling_mod_assign<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_pow.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_pow (line 29) | fn demo_mod_pow<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, l...
function demo_mod_pow_assign (line 38) | fn demo_mod_pow_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function benchmark_mod_pow_algorithms (line 49) | fn benchmark_mod_pow_algorithms<T: PrimitiveUnsigned>(
function benchmark_mod_pow_naive_algorithms (line 72) | fn benchmark_mod_pow_naive_algorithms<T: PrimitiveUnsigned>(
function benchmark_mod_pow_assign (line 98) | fn benchmark_mod_pow_assign<T: PrimitiveUnsigned>(
function benchmark_mod_pow_precomputed_algorithms (line 116) | fn benchmark_mod_pow_precomputed_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2.rs
function register (line 23) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_unsigned (line 51) | fn demo_mod_power_of_2_unsigned<T: PrimitiveUnsigned>(
function demo_mod_power_of_2_signed (line 64) | fn demo_mod_power_of_2_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_mod_power_of_2_assign_unsigned (line 76) | fn demo_mod_power_of_2_assign_unsigned<T: PrimitiveUnsigned>(
function demo_mod_power_of_2_assign_signed (line 91) | fn demo_mod_power_of_2_assign_signed<T: PrimitiveSigned>(
function demo_rem_power_of_2_unsigned (line 108) | fn demo_rem_power_of_2_unsigned<T: PrimitiveUnsigned>(
function demo_rem_power_of_2_signed (line 121) | fn demo_rem_power_of_2_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_rem_power_of_2_assign_unsigned (line 130) | fn demo_rem_power_of_2_assign_unsigned<T: PrimitiveUnsigned>(
function demo_rem_power_of_2_assign_signed (line 145) | fn demo_rem_power_of_2_assign_signed<T: PrimitiveSigned>(
function demo_neg_mod_power_of_2 (line 160) | fn demo_neg_mod_power_of_2<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_neg_mod_power_of_2_assign (line 171) | fn demo_neg_mod_power_of_2_assign<T: PrimitiveUnsigned>(
function demo_ceiling_mod_power_of_2 (line 183) | fn demo_ceiling_mod_power_of_2<
function demo_ceiling_mod_power_of_2_assign (line 204) | fn demo_ceiling_mod_power_of_2_assign<
function benchmark_mod_power_of_2_unsigned (line 222) | fn benchmark_mod_power_of_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_signed (line 240) | fn benchmark_mod_power_of_2_signed<T: PrimitiveSigned>(
function benchmark_mod_power_of_2_assign_unsigned (line 260) | fn benchmark_mod_power_of_2_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_assign_signed (line 280) | fn benchmark_mod_power_of_2_assign_signed<T: PrimitiveSigned>(
function benchmark_rem_power_of_2_unsigned (line 300) | fn benchmark_rem_power_of_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_rem_power_of_2_signed (line 318) | fn benchmark_rem_power_of_2_signed<T: PrimitiveSigned>(
function benchmark_rem_power_of_2_assign_unsigned (line 338) | fn benchmark_rem_power_of_2_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_rem_power_of_2_assign_signed (line 358) | fn benchmark_rem_power_of_2_assign_signed<T: PrimitiveSigned>(
function benchmark_neg_mod_power_of_2 (line 378) | fn benchmark_neg_mod_power_of_2<T: PrimitiveUnsigned>(
function benchmark_neg_mod_power_of_2_assign (line 398) | fn benchmark_neg_mod_power_of_2_assign<T: PrimitiveUnsigned>(
function benchmark_ceiling_mod_power_of_2 (line 418) | fn benchmark_ceiling_mod_power_of_2<
function benchmark_ceiling_mod_power_of_2_assign (line 441) | fn benchmark_ceiling_mod_power_of_2_assign<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_add.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_add (line 23) | fn demo_mod_power_of_2_add<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_mod_power_of_2_add_assign (line 38) | fn demo_mod_power_of_2_add_assign<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_add (line 53) | fn benchmark_mod_power_of_2_add<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_add_assign (line 73) | fn benchmark_mod_power_of_2_add_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_inverse.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_inverse (line 25) | fn demo_mod_power_of_2_inverse<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_inverse_algorithms (line 39) | fn benchmark_mod_power_of_2_inverse_algorithms<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_is_reduced.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_is_reduced (line 21) | fn demo_mod_power_of_2_is_reduced<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_is_reduced (line 38) | fn benchmark_mod_power_of_2_is_reduced<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_mul.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_mul (line 23) | fn demo_mod_power_of_2_mul<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_mod_power_of_2_mul_assign (line 38) | fn demo_mod_power_of_2_mul_assign<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_mul (line 53) | fn benchmark_mod_power_of_2_mul<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_mul_assign (line 73) | fn benchmark_mod_power_of_2_mul_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_neg.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_neg (line 23) | fn demo_mod_power_of_2_neg<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_mod_power_of_2_neg_assign (line 29) | fn demo_mod_power_of_2_neg_assign<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_neg (line 41) | fn benchmark_mod_power_of_2_neg<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_neg_assign (line 61) | fn benchmark_mod_power_of_2_neg_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_pow.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_pow (line 23) | fn demo_mod_power_of_2_pow<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_mod_power_of_2_pow_assign (line 38) | fn demo_mod_power_of_2_pow_assign<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_pow (line 53) | fn benchmark_mod_power_of_2_pow<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_pow_assign (line 73) | fn benchmark_mod_power_of_2_pow_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_shl.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_shl_unsigned_unsigned (line 35) | fn demo_mod_power_of_2_shl_unsigned_unsigned<
function demo_mod_power_of_2_shl_unsigned_signed (line 57) | fn demo_mod_power_of_2_shl_unsigned_signed<
function demo_mod_power_of_2_shl_assign_unsigned_unsigned (line 79) | fn demo_mod_power_of_2_shl_assign_unsigned_unsigned<
function demo_mod_power_of_2_shl_assign_unsigned_signed (line 97) | fn demo_mod_power_of_2_shl_assign_unsigned_signed<
function benchmark_mod_power_of_2_shl_unsigned_unsigned (line 115) | fn benchmark_mod_power_of_2_shl_unsigned_unsigned<
function benchmark_mod_power_of_2_shl_unsigned_signed (line 138) | fn benchmark_mod_power_of_2_shl_unsigned_signed<
function benchmark_mod_power_of_2_shl_assign_unsigned_unsigned (line 161) | fn benchmark_mod_power_of_2_shl_assign_unsigned_unsigned<
function benchmark_mod_power_of_2_shl_assign_unsigned_signed (line 184) | fn benchmark_mod_power_of_2_shl_assign_unsigned_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_shr.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_shr (line 26) | fn demo_mod_power_of_2_shr<
function demo_mod_power_of_2_shr_assign (line 48) | fn demo_mod_power_of_2_shr_assign<
function benchmark_mod_power_of_2_shr (line 66) | fn benchmark_mod_power_of_2_shr<
function benchmark_mod_power_of_2_shr_assign (line 89) | fn benchmark_mod_power_of_2_shr_assign<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_square.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_square (line 23) | fn demo_mod_power_of_2_square<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_mod_power_of_2_square_assign (line 34) | fn demo_mod_power_of_2_square_assign<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_square (line 46) | fn benchmark_mod_power_of_2_square<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_square_assign (line 66) | fn benchmark_mod_power_of_2_square_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_sub.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_power_of_2_sub (line 23) | fn demo_mod_power_of_2_sub<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_mod_power_of_2_sub_assign (line 38) | fn demo_mod_power_of_2_sub_assign<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_sub (line 53) | fn benchmark_mod_power_of_2_sub<T: PrimitiveUnsigned>(
function benchmark_mod_power_of_2_sub_assign (line 73) | fn benchmark_mod_power_of_2_sub_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_shl.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_shl_unsigned_unsigned (line 36) | fn demo_mod_shl_unsigned_unsigned<
function demo_mod_shl_unsigned_signed (line 52) | fn demo_mod_shl_unsigned_signed<
function demo_mod_shl_assign_unsigned_unsigned (line 69) | fn demo_mod_shl_assign_unsigned_unsigned<
function demo_mod_shl_assign_unsigned_signed (line 87) | fn demo_mod_shl_assign_unsigned_signed<
function benchmark_mod_shl_unsigned_unsigned (line 106) | fn benchmark_mod_shl_unsigned_unsigned<
function benchmark_mod_shl_unsigned_signed (line 127) | fn benchmark_mod_shl_unsigned_signed<
function benchmark_mod_shl_assign_unsigned_unsigned (line 149) | fn benchmark_mod_shl_assign_unsigned_unsigned<
function benchmark_mod_shl_assign_unsigned_signed (line 170) | fn benchmark_mod_shl_assign_unsigned_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_shr.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_shr (line 27) | fn demo_mod_shr<
function demo_mod_shr_assign (line 44) | fn demo_mod_shr_assign<
function benchmark_mod_shr (line 63) | fn benchmark_mod_shr<
function benchmark_mod_shr_assign (line 85) | fn benchmark_mod_shr_assign<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_square.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_square (line 24) | fn demo_mod_square<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig...
function demo_mod_square_assign (line 30) | fn demo_mod_square_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &Ge...
function benchmark_mod_square (line 38) | fn benchmark_mod_square<T: PrimitiveUnsigned>(
function benchmark_mod_square_assign (line 56) | fn benchmark_mod_square_assign<T: PrimitiveUnsigned>(
function benchmark_mod_square_precomputed_algorithms (line 74) | fn benchmark_mod_square_precomputed_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_sub.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_mod_sub (line 23) | fn demo_mod_sub<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, l...
function demo_mod_sub_assign (line 32) | fn demo_mod_sub_assign<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCo...
function benchmark_mod_sub (line 43) | fn benchmark_mod_sub<T: PrimitiveUnsigned>(
function benchmark_mod_sub_assign (line 61) | fn benchmark_mod_sub_assign<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/neg.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_neg_assign_signed (line 26) | fn demo_neg_assign_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function demo_neg_assign_primitive_float (line 34) | fn demo_neg_assign_primitive_float<T: PrimitiveFloat>(
function benchmark_neg_assign_signed (line 50) | fn benchmark_neg_assign_signed<T: PrimitiveSigned>(
function benchmark_neg_assign_primitive_float (line 68) | fn benchmark_neg_assign_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/next_power_of_2.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_next_power_of_2_primitive_float (line 30) | fn demo_next_power_of_2_primitive_float<T: PrimitiveFloat>(
function demo_next_power_of_2_assign_unsigned (line 47) | fn demo_next_power_of_2_assign_unsigned<T: PrimitiveUnsigned>(
function demo_next_power_of_2_assign_primitive_float (line 59) | fn demo_next_power_of_2_assign_primitive_float<T: PrimitiveFloat>(
function benchmark_next_power_of_2_primitive_float (line 78) | fn benchmark_next_power_of_2_primitive_float<T: PrimitiveFloat>(
function benchmark_next_power_of_2_assign_unsigned (line 96) | fn benchmark_next_power_of_2_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_next_power_of_2_assign_primitive_float (line 114) | fn benchmark_next_power_of_2_assign_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_abs.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_abs_assign (line 21) | fn demo_overflowing_abs_assign<T: PrimitiveSigned>(gm: GenMode, config: ...
function benchmark_overflowing_abs_assign (line 29) | fn benchmark_overflowing_abs_assign<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_add.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_add_unsigned (line 29) | fn demo_overflowing_add_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_add_signed (line 39) | fn demo_overflowing_add_signed<T: PrimitiveSigned>(gm: GenMode, config: ...
function demo_overflowing_add_assign_unsigned (line 50) | fn demo_overflowing_add_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_add_assign_signed (line 62) | fn demo_overflowing_add_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_add_unsigned (line 74) | fn benchmark_overflowing_add_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_add_signed (line 92) | fn benchmark_overflowing_add_signed<T: PrimitiveSigned>(
function benchmark_overflowing_add_assign_unsigned (line 110) | fn benchmark_overflowing_add_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_add_assign_signed (line 130) | fn benchmark_overflowing_add_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_add_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_add_mul_unsigned (line 29) | fn demo_overflowing_add_mul_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_add_mul_signed (line 48) | fn demo_overflowing_add_mul_signed<T: PrimitiveSigned>(
function demo_overflowing_add_mul_assign_unsigned (line 64) | fn demo_overflowing_add_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_add_mul_assign_signed (line 79) | fn demo_overflowing_add_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_add_mul_unsigned (line 91) | fn benchmark_overflowing_add_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_add_mul_signed (line 111) | fn benchmark_overflowing_add_mul_signed<T: PrimitiveSigned>(
function benchmark_overflowing_add_mul_assign_unsigned (line 131) | fn benchmark_overflowing_add_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_add_mul_assign_signed (line 156) | fn benchmark_overflowing_add_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_div.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_div_unsigned (line 29) | fn demo_overflowing_div_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_div_signed (line 42) | fn demo_overflowing_div_signed<T: PrimitiveSigned>(gm: GenMode, config: ...
function demo_overflowing_div_assign_unsigned (line 53) | fn demo_overflowing_div_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_div_assign_signed (line 68) | fn demo_overflowing_div_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_div_unsigned (line 80) | fn benchmark_overflowing_div_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_div_signed (line 98) | fn benchmark_overflowing_div_signed<T: PrimitiveSigned>(
function benchmark_overflowing_div_assign_unsigned (line 116) | fn benchmark_overflowing_div_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_div_assign_signed (line 136) | fn benchmark_overflowing_div_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_mul_unsigned (line 29) | fn demo_overflowing_mul_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_mul_signed (line 39) | fn demo_overflowing_mul_signed<T: PrimitiveSigned>(gm: GenMode, config: ...
function demo_overflowing_mul_assign_unsigned (line 50) | fn demo_overflowing_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_mul_assign_signed (line 62) | fn demo_overflowing_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_mul_unsigned (line 74) | fn benchmark_overflowing_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_mul_signed (line 92) | fn benchmark_overflowing_mul_signed<T: PrimitiveSigned>(
function benchmark_overflowing_mul_assign_unsigned (line 110) | fn benchmark_overflowing_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_mul_assign_signed (line 130) | fn benchmark_overflowing_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_neg.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_neg_assign_unsigned (line 24) | fn demo_overflowing_neg_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_neg_assign_signed (line 36) | fn demo_overflowing_neg_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_neg_assign_unsigned (line 48) | fn benchmark_overflowing_neg_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_neg_assign_signed (line 68) | fn benchmark_overflowing_neg_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_pow.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_pow_assign_unsigned (line 24) | fn demo_overflowing_pow_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_pow_assign_signed (line 36) | fn demo_overflowing_pow_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_pow_assign_unsigned (line 51) | fn benchmark_overflowing_pow_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_pow_assign_signed (line 71) | fn benchmark_overflowing_pow_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_square.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_square_unsigned (line 29) | fn demo_overflowing_square_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_square_signed (line 39) | fn demo_overflowing_square_signed<T: PrimitiveSigned>(
function demo_overflowing_square_assign_unsigned (line 49) | fn demo_overflowing_square_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_square_assign_signed (line 61) | fn demo_overflowing_square_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_square_unsigned (line 73) | fn benchmark_overflowing_square_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_square_signed (line 91) | fn benchmark_overflowing_square_signed<T: PrimitiveSigned>(
function benchmark_overflowing_square_assign_unsigned (line 109) | fn benchmark_overflowing_square_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_square_assign_signed (line 129) | fn benchmark_overflowing_square_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_sub.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_sub_unsigned (line 29) | fn demo_overflowing_sub_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_sub_signed (line 39) | fn demo_overflowing_sub_signed<T: PrimitiveSigned>(gm: GenMode, config: ...
function demo_overflowing_sub_assign_unsigned (line 50) | fn demo_overflowing_sub_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_sub_assign_signed (line 62) | fn demo_overflowing_sub_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_sub_unsigned (line 74) | fn benchmark_overflowing_sub_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_sub_signed (line 92) | fn benchmark_overflowing_sub_signed<T: PrimitiveSigned>(
function benchmark_overflowing_sub_assign_unsigned (line 110) | fn benchmark_overflowing_sub_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_sub_assign_signed (line 130) | fn benchmark_overflowing_sub_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_sub_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_overflowing_sub_mul_unsigned (line 29) | fn demo_overflowing_sub_mul_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_sub_mul_signed (line 48) | fn demo_overflowing_sub_mul_signed<T: PrimitiveSigned>(
function demo_overflowing_sub_mul_assign_unsigned (line 64) | fn demo_overflowing_sub_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_overflowing_sub_mul_assign_signed (line 79) | fn demo_overflowing_sub_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_overflowing_sub_mul_unsigned (line 91) | fn benchmark_overflowing_sub_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_sub_mul_signed (line 111) | fn benchmark_overflowing_sub_mul_signed<T: PrimitiveSigned>(
function benchmark_overflowing_sub_mul_assign_unsigned (line 131) | fn benchmark_overflowing_sub_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_overflowing_sub_mul_assign_signed (line 156) | fn benchmark_overflowing_sub_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/parity.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_even_unsigned (line 29) | fn demo_even_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCon...
function demo_even_signed (line 39) | fn demo_even_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfig,...
function demo_odd_unsigned (line 49) | fn demo_odd_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConf...
function demo_odd_signed (line 59) | fn demo_odd_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfig, ...
function benchmark_even_unsigned (line 69) | fn benchmark_even_unsigned<T: PrimitiveUnsigned>(
function benchmark_even_signed (line 87) | fn benchmark_even_signed<T: PrimitiveSigned>(
function benchmark_odd_unsigned (line 105) | fn benchmark_odd_unsigned<T: PrimitiveUnsigned>(
function benchmark_odd_signed (line 123) | fn benchmark_odd_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/pow.rs
function register (line 24) | pub(crate) fn register(runner: &mut Runner) {
function demo_pow_assign_unsigned (line 36) | fn demo_pow_assign_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_pow_assign_signed (line 44) | fn demo_pow_assign_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function demo_pow_assign_i64_primitive_float (line 55) | fn demo_pow_assign_i64_primitive_float<T: PrimitiveFloat>(
function demo_pow_assign_primitive_float_primitive_float (line 75) | fn demo_pow_assign_primitive_float_primitive_float<T: PrimitiveFloat>(
function benchmark_pow_assign_unsigned (line 92) | fn benchmark_pow_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_pow_assign_signed (line 110) | fn benchmark_pow_assign_signed<T: PrimitiveSigned>(
function benchmark_pow_assign_i64_primitive_float (line 128) | fn benchmark_pow_assign_i64_primitive_float<T: PrimitiveFloat>(
function benchmark_pow_assign_primitive_float_primitive_float (line 146) | fn benchmark_pow_assign_primitive_float_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/power_of_2.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_power_of_2_unsigned (line 32) | fn demo_power_of_2_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_power_of_2_signed (line 38) | fn demo_power_of_2_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function demo_power_of_2_primitive_float_unsigned (line 44) | fn demo_power_of_2_primitive_float_unsigned<T: PrimitiveFloat>(
function demo_power_of_2_primitive_float_signed (line 54) | fn demo_power_of_2_primitive_float_signed<T: PrimitiveFloat>(
function benchmark_power_of_2_unsigned (line 64) | fn benchmark_power_of_2_unsigned<T: PrimitiveUnsigned>(
function benchmark_power_of_2_signed (line 82) | fn benchmark_power_of_2_signed<T: PrimitiveSigned>(
function benchmark_power_of_2_primitive_float_unsigned (line 100) | fn benchmark_power_of_2_primitive_float_unsigned<T: PrimitiveFloat>(
function benchmark_power_of_2_primitive_float_signed (line 118) | fn benchmark_power_of_2_primitive_float_signed<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/primorial.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_primorial (line 33) | fn demo_primorial<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig,...
function demo_checked_primorial (line 39) | fn demo_checked_primorial<T: PrimitiveUnsigned>(gm: GenMode, config: &Ge...
function demo_product_of_first_n_primes (line 45) | fn demo_product_of_first_n_primes<T: PrimitiveUnsigned>(
function demo_checked_product_of_first_n_primes (line 55) | fn demo_checked_product_of_first_n_primes<T: PrimitiveUnsigned>(
function benchmark_primorial_algorithms (line 65) | fn benchmark_primorial_algorithms<T: PrimitiveUnsigned>(
function benchmark_checked_primorial (line 88) | fn benchmark_checked_primorial<T: PrimitiveUnsigned>(
function benchmark_product_of_first_n_primes_algorithms (line 106) | fn benchmark_product_of_first_n_primes_algorithms<T: PrimitiveUnsigned>(
function benchmark_checked_product_of_first_n_primes (line 129) | fn benchmark_checked_product_of_first_n_primes<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/reciprocal.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_reciprocal_primitive_float (line 25) | fn demo_reciprocal_primitive_float<T: PrimitiveFloat>(
function demo_reciprocal_assign_primitive_float (line 39) | fn demo_reciprocal_assign_primitive_float<T: PrimitiveFloat>(
function benchmark_reciprocal_primitive_float (line 55) | fn benchmark_reciprocal_primitive_float<T: PrimitiveFloat>(
function benchmark_reciprocal_assign_primitive_float (line 73) | fn benchmark_reciprocal_assign_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/root.rs
function register (line 33) | pub(crate) fn register(runner: &mut Runner) {
function demo_floor_cbrt_unsigned (line 110) | fn demo_floor_cbrt_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_floor_cbrt_signed (line 116) | fn demo_floor_cbrt_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function demo_floor_cbrt_assign_unsigned (line 122) | fn demo_floor_cbrt_assign_unsigned<T: PrimitiveUnsigned>(
function demo_floor_cbrt_assign_signed (line 134) | fn demo_floor_cbrt_assign_signed<T: PrimitiveSigned>(
function demo_ceiling_cbrt_unsigned (line 146) | fn demo_ceiling_cbrt_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_ceiling_cbrt_signed (line 152) | fn demo_ceiling_cbrt_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_ceiling_cbrt_assign_unsigned (line 158) | fn demo_ceiling_cbrt_assign_unsigned<T: PrimitiveUnsigned>(
function demo_ceiling_cbrt_assign_signed (line 170) | fn demo_ceiling_cbrt_assign_signed<T: PrimitiveSigned>(
function demo_checked_cbrt_unsigned (line 182) | fn demo_checked_cbrt_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_checked_cbrt_signed (line 188) | fn demo_checked_cbrt_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_cbrt_rem (line 194) | fn demo_cbrt_rem<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, ...
function demo_cbrt_assign_rem (line 200) | fn demo_cbrt_assign_rem<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function demo_floor_root_unsigned (line 208) | fn demo_floor_root_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_floor_root_signed (line 217) | fn demo_floor_root_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function demo_floor_root_assign_unsigned (line 226) | fn demo_floor_root_assign_unsigned<T: PrimitiveUnsigned>(
function demo_floor_root_assign_signed (line 241) | fn demo_floor_root_assign_signed<T: PrimitiveSigned>(
function demo_ceiling_root_unsigned (line 256) | fn demo_ceiling_root_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_ceiling_root_signed (line 265) | fn demo_ceiling_root_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_ceiling_root_assign_unsigned (line 274) | fn demo_ceiling_root_assign_unsigned<T: PrimitiveUnsigned>(
function demo_ceiling_root_assign_signed (line 289) | fn demo_ceiling_root_assign_signed<T: PrimitiveSigned>(
function demo_checked_root_unsigned (line 304) | fn demo_checked_root_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_checked_root_signed (line 313) | fn demo_checked_root_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_root_rem (line 322) | fn demo_root_rem<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, ...
function demo_root_assign_rem (line 331) | fn demo_root_assign_rem<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function benchmark_floor_cbrt_signed (line 377) | fn benchmark_floor_cbrt_signed<T: PrimitiveSigned>(
function benchmark_floor_cbrt_assign_unsigned (line 395) | fn benchmark_floor_cbrt_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_floor_cbrt_assign_signed (line 413) | fn benchmark_floor_cbrt_assign_signed<T: PrimitiveSigned>(
function benchmark_ceiling_cbrt_algorithms_unsigned (line 431) | fn benchmark_ceiling_cbrt_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_ceiling_cbrt_signed (line 452) | fn benchmark_ceiling_cbrt_signed<T: PrimitiveSigned>(
function benchmark_ceiling_cbrt_assign_unsigned (line 470) | fn benchmark_ceiling_cbrt_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_ceiling_cbrt_assign_signed (line 488) | fn benchmark_ceiling_cbrt_assign_signed<T: PrimitiveSigned>(
function benchmark_checked_cbrt_algorithms_unsigned (line 506) | fn benchmark_checked_cbrt_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_cbrt_signed (line 527) | fn benchmark_checked_cbrt_signed<T: PrimitiveSigned>(
function benchmark_cbrt_rem_algorithms (line 545) | fn benchmark_cbrt_rem_algorithms<T: PrimitiveUnsigned>(
function benchmark_cbrt_assign_rem (line 566) | fn benchmark_cbrt_assign_rem<T: PrimitiveUnsigned>(
function benchmark_floor_root_signed (line 619) | fn benchmark_floor_root_signed<T: PrimitiveSigned>(
function benchmark_floor_root_assign_unsigned (line 637) | fn benchmark_floor_root_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_floor_root_assign_signed (line 655) | fn benchmark_floor_root_assign_signed<T: PrimitiveSigned>(
function benchmark_ceiling_root_algorithms_unsigned (line 673) | fn benchmark_ceiling_root_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_ceiling_root_signed (line 696) | fn benchmark_ceiling_root_signed<T: PrimitiveSigned>(
function benchmark_ceiling_root_assign_unsigned (line 714) | fn benchmark_ceiling_root_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_ceiling_root_assign_signed (line 732) | fn benchmark_ceiling_root_assign_signed<T: PrimitiveSigned>(
function benchmark_checked_root_algorithms_unsigned (line 750) | fn benchmark_checked_root_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_root_signed (line 773) | fn benchmark_checked_root_signed<T: PrimitiveSigned>(
function benchmark_root_rem_algorithms (line 791) | fn benchmark_root_rem_algorithms<T: PrimitiveUnsigned>(
function benchmark_root_assign_rem (line 812) | fn benchmark_root_assign_rem<T: PrimitiveUnsigned>(
function benchmark_floor_cbrt_algorithms_2_u32 (line 832) | fn benchmark_floor_cbrt_algorithms_2_u32(
function benchmark_floor_cbrt_algorithms_2_u64 (line 858) | fn benchmark_floor_cbrt_algorithms_2_u64(
function benchmark_floor_root_algorithms_2_u32 (line 889) | fn benchmark_floor_root_algorithms_2_u32(
function benchmark_floor_root_algorithms_2_u64 (line 919) | fn benchmark_floor_root_algorithms_2_u64(
function benchmark_ceiling_root_algorithms_2_u32 (line 949) | fn benchmark_ceiling_root_algorithms_2_u32(
function benchmark_ceiling_root_algorithms_2_u64 (line 975) | fn benchmark_ceiling_root_algorithms_2_u64(
function benchmark_checked_root_algorithms_2_u32 (line 1001) | fn benchmark_checked_root_algorithms_2_u32(
function benchmark_checked_root_algorithms_2_u64 (line 1027) | fn benchmark_checked_root_algorithms_2_u64(
function benchmark_root_rem_algorithms_2_u32 (line 1053) | fn benchmark_root_rem_algorithms_2_u32(
function benchmark_root_rem_algorithms_2_u64 (line 1075) | fn benchmark_root_rem_algorithms_2_u64(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/rotate.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_rotate_left_assign_unsigned (line 29) | fn demo_rotate_left_assign_unsigned<T: PrimitiveUnsigned>(
function demo_rotate_left_assign_signed (line 41) | fn demo_rotate_left_assign_signed<T: PrimitiveSigned>(
function demo_rotate_right_assign_unsigned (line 56) | fn demo_rotate_right_assign_unsigned<T: PrimitiveUnsigned>(
function demo_rotate_right_assign_signed (line 68) | fn demo_rotate_right_assign_signed<T: PrimitiveSigned>(
function benchmark_rotate_left_assign_unsigned (line 83) | fn benchmark_rotate_left_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_rotate_left_assign_signed (line 101) | fn benchmark_rotate_left_assign_signed<T: PrimitiveSigned>(
function benchmark_rotate_right_assign_unsigned (line 119) | fn benchmark_rotate_right_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_rotate_right_assign_signed (line 137) | fn benchmark_rotate_right_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/round_to_multiple.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_round_to_multiple_unsigned (line 33) | fn demo_round_to_multiple_unsigned<T: PrimitiveUnsigned>(
function demo_round_to_multiple_assign_unsigned (line 52) | fn demo_round_to_multiple_assign_unsigned<T: PrimitiveUnsigned>(
function demo_round_to_multiple_signed (line 67) | fn demo_round_to_multiple_signed<
function demo_round_to_multiple_assign_signed (line 89) | fn demo_round_to_multiple_assign_signed<
function benchmark_round_to_multiple_unsigned (line 107) | fn benchmark_round_to_multiple_unsigned<T: PrimitiveUnsigned>(
function benchmark_round_to_multiple_assign_unsigned (line 127) | fn benchmark_round_to_multiple_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_round_to_multiple_signed (line 151) | fn benchmark_round_to_multiple_signed<
function benchmark_round_to_multiple_assign_signed (line 174) | fn benchmark_round_to_multiple_assign_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/round_to_multiple_of_power_of_2.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_round_to_multiple_of_power_of_2_unsigned (line 38) | fn demo_round_to_multiple_of_power_of_2_unsigned<T: PrimitiveUnsigned>(
function demo_round_to_multiple_of_power_of_2_assign_unsigned (line 57) | fn demo_round_to_multiple_of_power_of_2_assign_unsigned<T: PrimitiveUnsi...
function demo_round_to_multiple_of_power_of_2_signed (line 74) | fn demo_round_to_multiple_of_power_of_2_signed<T: PrimitiveSigned>(
function demo_round_to_multiple_of_power_of_2_assign_signed (line 93) | fn demo_round_to_multiple_of_power_of_2_assign_signed<T: PrimitiveSigned>(
function benchmark_round_to_multiple_of_power_of_2_unsigned (line 110) | fn benchmark_round_to_multiple_of_power_of_2_unsigned<T: PrimitiveUnsign...
function benchmark_round_to_multiple_of_power_of_2_assign_unsigned (line 134) | fn benchmark_round_to_multiple_of_power_of_2_assign_unsigned<T: Primitiv...
function benchmark_round_to_multiple_of_power_of_2_signed (line 158) | fn benchmark_round_to_multiple_of_power_of_2_signed<T: PrimitiveSigned>(
function benchmark_round_to_multiple_of_power_of_2_assign_signed (line 182) | fn benchmark_round_to_multiple_of_power_of_2_assign_signed<T: PrimitiveS...
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_abs.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_abs_assign (line 21) | fn demo_saturating_abs_assign<T: PrimitiveSigned>(gm: GenMode, config: &...
function benchmark_saturating_abs_assign (line 29) | fn benchmark_saturating_abs_assign<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_add.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_add_unsigned (line 29) | fn demo_saturating_add_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_add_signed (line 39) | fn demo_saturating_add_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_saturating_add_assign_unsigned (line 45) | fn demo_saturating_add_assign_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_add_assign_signed (line 57) | fn demo_saturating_add_assign_signed<T: PrimitiveSigned>(
function benchmark_saturating_add_unsigned (line 69) | fn benchmark_saturating_add_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_add_signed (line 87) | fn benchmark_saturating_add_signed<T: PrimitiveSigned>(
function benchmark_saturating_add_assign_unsigned (line 105) | fn benchmark_saturating_add_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_add_assign_signed (line 123) | fn benchmark_saturating_add_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_add_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_add_mul_unsigned (line 29) | fn demo_saturating_add_mul_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_add_mul_signed (line 48) | fn demo_saturating_add_mul_signed<T: PrimitiveSigned>(
function demo_saturating_add_mul_assign_unsigned (line 64) | fn demo_saturating_add_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_add_mul_assign_signed (line 79) | fn demo_saturating_add_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_saturating_add_mul_unsigned (line 91) | fn benchmark_saturating_add_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_add_mul_signed (line 111) | fn benchmark_saturating_add_mul_signed<T: PrimitiveSigned>(
function benchmark_saturating_add_mul_assign_unsigned (line 131) | fn benchmark_saturating_add_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_add_mul_assign_signed (line 156) | fn benchmark_saturating_add_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_mul_unsigned (line 29) | fn demo_saturating_mul_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_mul_signed (line 39) | fn demo_saturating_mul_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_saturating_mul_assign_unsigned (line 45) | fn demo_saturating_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_mul_assign_signed (line 57) | fn demo_saturating_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_saturating_mul_unsigned (line 69) | fn benchmark_saturating_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_mul_signed (line 87) | fn benchmark_saturating_mul_signed<T: PrimitiveSigned>(
function benchmark_saturating_mul_assign_unsigned (line 105) | fn benchmark_saturating_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_mul_assign_signed (line 123) | fn benchmark_saturating_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_neg.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_neg_assign (line 21) | fn demo_saturating_neg_assign<T: PrimitiveSigned>(gm: GenMode, config: &...
function benchmark_saturating_neg_assign (line 29) | fn benchmark_saturating_neg_assign<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_pow.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_pow_assign_unsigned (line 24) | fn demo_saturating_pow_assign_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_pow_assign_signed (line 36) | fn demo_saturating_pow_assign_signed<T: PrimitiveSigned>(
function benchmark_saturating_pow_assign_unsigned (line 51) | fn benchmark_saturating_pow_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_pow_assign_signed (line 69) | fn benchmark_saturating_pow_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_square.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_square_unsigned (line 29) | fn demo_saturating_square_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_square_signed (line 39) | fn demo_saturating_square_signed<T: PrimitiveSigned>(
function demo_saturating_square_assign_unsigned (line 49) | fn demo_saturating_square_assign_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_square_assign_signed (line 61) | fn demo_saturating_square_assign_signed<T: PrimitiveSigned>(
function benchmark_saturating_square_unsigned (line 73) | fn benchmark_saturating_square_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_square_signed (line 91) | fn benchmark_saturating_square_signed<T: PrimitiveSigned>(
function benchmark_saturating_square_assign_unsigned (line 109) | fn benchmark_saturating_square_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_square_assign_signed (line 127) | fn benchmark_saturating_square_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_sub.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_sub_unsigned (line 29) | fn demo_saturating_sub_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_sub_signed (line 39) | fn demo_saturating_sub_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_saturating_sub_assign_unsigned (line 45) | fn demo_saturating_sub_assign_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_sub_assign_signed (line 57) | fn demo_saturating_sub_assign_signed<T: PrimitiveSigned>(
function benchmark_saturating_sub_unsigned (line 69) | fn benchmark_saturating_sub_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_sub_signed (line 87) | fn benchmark_saturating_sub_signed<T: PrimitiveSigned>(
function benchmark_saturating_sub_assign_unsigned (line 105) | fn benchmark_saturating_sub_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_sub_assign_signed (line 123) | fn benchmark_saturating_sub_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_sub_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_saturating_sub_mul_unsigned (line 29) | fn demo_saturating_sub_mul_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_sub_mul_signed (line 48) | fn demo_saturating_sub_mul_signed<T: PrimitiveSigned>(
function demo_saturating_sub_mul_assign_unsigned (line 64) | fn demo_saturating_sub_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_saturating_sub_mul_assign_signed (line 79) | fn demo_saturating_sub_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_saturating_sub_mul_unsigned (line 91) | fn benchmark_saturating_sub_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_sub_mul_signed (line 111) | fn benchmark_saturating_sub_mul_signed<T: PrimitiveSigned>(
function benchmark_saturating_sub_mul_assign_unsigned (line 131) | fn benchmark_saturating_sub_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_saturating_sub_mul_assign_signed (line 156) | fn benchmark_saturating_sub_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/shl_round.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_shl_round_unsigned_signed (line 32) | fn demo_shl_round_unsigned_signed<
function demo_shl_round_signed_signed (line 48) | fn demo_shl_round_signed_signed<
function demo_shl_round_assign_unsigned_signed (line 70) | fn demo_shl_round_assign_unsigned_signed<
function demo_shl_round_assign_signed_signed (line 88) | fn demo_shl_round_assign_signed_signed<
function benchmark_shl_round_unsigned_signed (line 106) | fn benchmark_shl_round_unsigned_signed<
function benchmark_shl_round_signed_signed (line 129) | fn benchmark_shl_round_signed_signed<
function benchmark_shl_round_assign_unsigned_signed (line 152) | fn benchmark_shl_round_assign_unsigned_signed<
function benchmark_shl_round_assign_signed_signed (line 177) | fn benchmark_shl_round_assign_signed_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/shr_round.rs
function register (line 24) | pub(crate) fn register(runner: &mut Runner) {
function demo_shr_round_unsigned_unsigned (line 44) | fn demo_shr_round_unsigned_unsigned<
function demo_shr_round_unsigned_signed (line 60) | fn demo_shr_round_unsigned_signed<
function demo_shr_round_signed_unsigned (line 76) | fn demo_shr_round_signed_unsigned<
function demo_shr_round_signed_signed (line 98) | fn demo_shr_round_signed_signed<
function demo_shr_round_assign_unsigned_unsigned (line 120) | fn demo_shr_round_assign_unsigned_unsigned<
function demo_shr_round_assign_unsigned_signed (line 138) | fn demo_shr_round_assign_unsigned_signed<
function demo_shr_round_assign_signed_unsigned (line 156) | fn demo_shr_round_assign_signed_unsigned<
function demo_shr_round_assign_signed_signed (line 174) | fn demo_shr_round_assign_signed_signed<
function benchmark_shr_round_unsigned_unsigned (line 192) | fn benchmark_shr_round_unsigned_unsigned<
function benchmark_shr_round_unsigned_signed (line 215) | fn benchmark_shr_round_unsigned_signed<
function benchmark_shr_round_signed_unsigned (line 238) | fn benchmark_shr_round_signed_unsigned<
function benchmark_shr_round_signed_signed (line 261) | fn benchmark_shr_round_signed_signed<
function benchmark_shr_round_assign_unsigned_unsigned (line 284) | fn benchmark_shr_round_assign_unsigned_unsigned<
function benchmark_shr_round_assign_unsigned_signed (line 309) | fn benchmark_shr_round_assign_unsigned_signed<
function benchmark_shr_round_assign_signed_unsigned (line 334) | fn benchmark_shr_round_assign_signed_unsigned<
function benchmark_shr_round_assign_signed_signed (line 359) | fn benchmark_shr_round_assign_signed_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/sign.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_sign_unsigned (line 31) | fn demo_sign_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCon...
function demo_sign_signed (line 37) | fn demo_sign_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfig,...
function demo_sign_primitive_float (line 43) | fn demo_sign_primitive_float<T: PrimitiveFloat>(gm: GenMode, config: &Ge...
function benchmark_sign_unsigned (line 49) | fn benchmark_sign_unsigned<T: PrimitiveUnsigned>(
function benchmark_sign_signed (line 67) | fn benchmark_sign_signed<T: PrimitiveSigned>(
function benchmark_sign_primitive_float (line 85) | fn benchmark_sign_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/sqrt.rs
function register (line 27) | pub(crate) fn register(runner: &mut Runner) {
function demo_floor_sqrt_unsigned (line 63) | fn demo_floor_sqrt_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_floor_sqrt_signed (line 69) | fn demo_floor_sqrt_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function demo_floor_sqrt_assign_unsigned (line 75) | fn demo_floor_sqrt_assign_unsigned<T: PrimitiveUnsigned>(
function demo_floor_sqrt_assign_signed (line 87) | fn demo_floor_sqrt_assign_signed<T: PrimitiveSigned>(
function demo_ceiling_sqrt_unsigned (line 99) | fn demo_ceiling_sqrt_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_ceiling_sqrt_signed (line 105) | fn demo_ceiling_sqrt_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_ceiling_sqrt_assign_unsigned (line 111) | fn demo_ceiling_sqrt_assign_unsigned<T: PrimitiveUnsigned>(
function demo_ceiling_sqrt_assign_signed (line 123) | fn demo_ceiling_sqrt_assign_signed<T: PrimitiveSigned>(
function demo_checked_sqrt_unsigned (line 135) | fn demo_checked_sqrt_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_checked_sqrt_signed (line 141) | fn demo_checked_sqrt_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_sqrt_rem (line 147) | fn demo_sqrt_rem<T: PrimitiveUnsigned>(gm: GenMode, config: &GenConfig, ...
function demo_sqrt_assign_rem (line 154) | fn demo_sqrt_assign_rem<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function demo_sqrt_assign (line 162) | fn demo_sqrt_assign<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig, ...
function benchmark_floor_sqrt_algorithms_unsigned (line 174) | fn benchmark_floor_sqrt_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_floor_sqrt_signed (line 195) | fn benchmark_floor_sqrt_signed<T: PrimitiveSigned>(
function benchmark_floor_sqrt_assign_unsigned (line 213) | fn benchmark_floor_sqrt_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_floor_sqrt_assign_signed (line 231) | fn benchmark_floor_sqrt_assign_signed<T: PrimitiveSigned>(
function benchmark_ceiling_sqrt_algorithms_unsigned (line 249) | fn benchmark_ceiling_sqrt_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_ceiling_sqrt_signed (line 270) | fn benchmark_ceiling_sqrt_signed<T: PrimitiveSigned>(
function benchmark_ceiling_sqrt_assign_unsigned (line 288) | fn benchmark_ceiling_sqrt_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_ceiling_sqrt_assign_signed (line 306) | fn benchmark_ceiling_sqrt_assign_signed<T: PrimitiveSigned>(
function benchmark_checked_sqrt_algorithms_unsigned (line 324) | fn benchmark_checked_sqrt_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_sqrt_signed (line 345) | fn benchmark_checked_sqrt_signed<T: PrimitiveSigned>(
function benchmark_sqrt_rem_algorithms (line 363) | fn benchmark_sqrt_rem_algorithms<T: PrimitiveUnsigned>(
function benchmark_sqrt_rem_algorithms_2 (line 385) | fn benchmark_sqrt_rem_algorithms_2<
function benchmark_sqrt_assign_rem (line 417) | fn benchmark_sqrt_assign_rem<T: PrimitiveUnsigned>(
function benchmark_sqrt_assign (line 435) | fn benchmark_sqrt_assign<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/square.rs
function register (line 24) | pub(crate) fn register(runner: &mut Runner) {
function demo_square_unsigned (line 40) | fn demo_square_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function demo_square_assign_unsigned (line 46) | fn demo_square_assign_unsigned<T: PrimitiveUnsigned>(
function demo_square_signed (line 58) | fn demo_square_signed<
function demo_square_assign_signed (line 71) | fn demo_square_assign_signed<
function demo_square_primitive_float (line 86) | fn demo_square_primitive_float<T: PrimitiveFloat>(gm: GenMode, config: &...
function demo_square_assign_primitive_float (line 92) | fn demo_square_assign_primitive_float<T: PrimitiveFloat>(
function benchmark_square_unsigned (line 108) | fn benchmark_square_unsigned<T: PrimitiveUnsigned>(
function benchmark_square_assign_unsigned (line 126) | fn benchmark_square_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_square_signed (line 144) | fn benchmark_square_signed<
function benchmark_square_assign_signed (line 165) | fn benchmark_square_assign_signed<
function benchmark_square_primitive_float (line 186) | fn benchmark_square_primitive_float<T: PrimitiveFloat>(
function benchmark_square_assign_primitive_float (line 204) | fn benchmark_square_assign_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/sub_mul.rs
function register (line 23) | pub(crate) fn register(runner: &mut Runner) {
function demo_sub_mul_unsigned (line 39) | fn demo_sub_mul_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_sub_mul_signed (line 45) | fn demo_sub_mul_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConf...
function demo_sub_mul_primitive_float (line 51) | fn demo_sub_mul_primitive_float<T: PrimitiveFloat>(gm: GenMode, config: ...
function demo_sub_mul_assign_unsigned (line 66) | fn demo_sub_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_sub_mul_assign_signed (line 78) | fn demo_sub_mul_assign_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_sub_mul_assign_primitive_float (line 86) | fn demo_sub_mul_assign_primitive_float<T: PrimitiveFloat>(
function benchmark_sub_mul_unsigned (line 107) | fn benchmark_sub_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_sub_mul_signed (line 125) | fn benchmark_sub_mul_signed<T: PrimitiveSigned>(
function benchmark_sub_mul_primitive_float (line 143) | fn benchmark_sub_mul_primitive_float<T: PrimitiveFloat>(
function benchmark_sub_mul_assign_unsigned (line 161) | fn benchmark_sub_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_sub_mul_assign_signed (line 179) | fn benchmark_sub_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_sub_mul_assign_primitive_float (line 197) | fn benchmark_sub_mul_assign_primitive_float<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_abs.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_abs_assign (line 21) | fn demo_wrapping_abs_assign<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function benchmark_wrapping_abs_assign (line 29) | fn benchmark_wrapping_abs_assign<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_add.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_add_unsigned (line 29) | fn demo_wrapping_add_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_wrapping_add_signed (line 35) | fn demo_wrapping_add_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_wrapping_add_assign_unsigned (line 41) | fn demo_wrapping_add_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_add_assign_signed (line 53) | fn demo_wrapping_add_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_add_unsigned (line 65) | fn benchmark_wrapping_add_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_add_signed (line 83) | fn benchmark_wrapping_add_signed<T: PrimitiveSigned>(
function benchmark_wrapping_add_assign_unsigned (line 101) | fn benchmark_wrapping_add_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_add_assign_signed (line 119) | fn benchmark_wrapping_add_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_add_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_add_mul_unsigned (line 29) | fn demo_wrapping_add_mul_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_add_mul_signed (line 48) | fn demo_wrapping_add_mul_signed<T: PrimitiveSigned>(gm: GenMode, config:...
function demo_wrapping_add_mul_assign_unsigned (line 60) | fn demo_wrapping_add_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_add_mul_assign_signed (line 75) | fn demo_wrapping_add_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_add_mul_unsigned (line 87) | fn benchmark_wrapping_add_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_add_mul_signed (line 107) | fn benchmark_wrapping_add_mul_signed<T: PrimitiveSigned>(
function benchmark_wrapping_add_mul_assign_unsigned (line 127) | fn benchmark_wrapping_add_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_add_mul_assign_signed (line 152) | fn benchmark_wrapping_add_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_div.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_div_unsigned (line 29) | fn demo_wrapping_div_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_wrapping_div_signed (line 38) | fn demo_wrapping_div_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_wrapping_div_assign_unsigned (line 44) | fn demo_wrapping_div_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_div_assign_signed (line 59) | fn demo_wrapping_div_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_div_unsigned (line 71) | fn benchmark_wrapping_div_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_div_signed (line 89) | fn benchmark_wrapping_div_signed<T: PrimitiveSigned>(
function benchmark_wrapping_div_assign_unsigned (line 107) | fn benchmark_wrapping_div_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_div_assign_signed (line 125) | fn benchmark_wrapping_div_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_mul_unsigned (line 29) | fn demo_wrapping_mul_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_wrapping_mul_signed (line 35) | fn demo_wrapping_mul_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_wrapping_mul_assign_unsigned (line 41) | fn demo_wrapping_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_mul_assign_signed (line 53) | fn demo_wrapping_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_mul_unsigned (line 65) | fn benchmark_wrapping_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_mul_signed (line 83) | fn benchmark_wrapping_mul_signed<T: PrimitiveSigned>(
function benchmark_wrapping_mul_assign_unsigned (line 101) | fn benchmark_wrapping_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_mul_assign_signed (line 119) | fn benchmark_wrapping_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_neg.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_neg_assign_unsigned (line 24) | fn demo_wrapping_neg_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_neg_assign_signed (line 36) | fn demo_wrapping_neg_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_neg_assign_unsigned (line 48) | fn benchmark_wrapping_neg_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_neg_assign_signed (line 66) | fn benchmark_wrapping_neg_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_pow.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_pow_assign_unsigned (line 24) | fn demo_wrapping_pow_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_pow_assign_signed (line 36) | fn demo_wrapping_pow_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_pow_assign_unsigned (line 51) | fn benchmark_wrapping_pow_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_pow_assign_signed (line 69) | fn benchmark_wrapping_pow_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_square.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_square_unsigned (line 29) | fn demo_wrapping_square_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_square_signed (line 39) | fn demo_wrapping_square_signed<T: PrimitiveSigned>(gm: GenMode, config: ...
function demo_wrapping_square_assign_unsigned (line 45) | fn demo_wrapping_square_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_square_assign_signed (line 57) | fn demo_wrapping_square_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_square_unsigned (line 69) | fn benchmark_wrapping_square_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_square_signed (line 87) | fn benchmark_wrapping_square_signed<T: PrimitiveSigned>(
function benchmark_wrapping_square_assign_unsigned (line 105) | fn benchmark_wrapping_square_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_square_assign_signed (line 123) | fn benchmark_wrapping_square_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_sub.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_sub_unsigned (line 29) | fn demo_wrapping_sub_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_wrapping_sub_signed (line 35) | fn demo_wrapping_sub_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function demo_wrapping_sub_assign_unsigned (line 41) | fn demo_wrapping_sub_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_sub_assign_signed (line 53) | fn demo_wrapping_sub_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_sub_unsigned (line 65) | fn benchmark_wrapping_sub_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_sub_signed (line 83) | fn benchmark_wrapping_sub_signed<T: PrimitiveSigned>(
function benchmark_wrapping_sub_assign_unsigned (line 101) | fn benchmark_wrapping_sub_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_sub_assign_signed (line 119) | fn benchmark_wrapping_sub_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_sub_mul.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_wrapping_sub_mul_unsigned (line 29) | fn demo_wrapping_sub_mul_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_sub_mul_signed (line 48) | fn demo_wrapping_sub_mul_signed<T: PrimitiveSigned>(gm: GenMode, config:...
function demo_wrapping_sub_mul_assign_unsigned (line 60) | fn demo_wrapping_sub_mul_assign_unsigned<T: PrimitiveUnsigned>(
function demo_wrapping_sub_mul_assign_signed (line 75) | fn demo_wrapping_sub_mul_assign_signed<T: PrimitiveSigned>(
function benchmark_wrapping_sub_mul_unsigned (line 87) | fn benchmark_wrapping_sub_mul_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_sub_mul_signed (line 107) | fn benchmark_wrapping_sub_mul_signed<T: PrimitiveSigned>(
function benchmark_wrapping_sub_mul_assign_unsigned (line 127) | fn benchmark_wrapping_sub_mul_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_wrapping_sub_mul_assign_signed (line 152) | fn benchmark_wrapping_sub_mul_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/x_mul_y_to_zz.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_x_mul_y_to_zz (line 22) | fn demo_x_mul_y_to_zz<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCon...
function benchmark_x_mul_y_to_zz_algorithms (line 28) | fn benchmark_x_mul_y_to_zz_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xx_add_yy_to_zz.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_xx_add_yy_to_zz (line 22) | fn demo_xx_add_yy_to_zz<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function benchmark_xx_add_yy_to_zz_algorithms (line 38) | fn benchmark_xx_add_yy_to_zz_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xx_div_mod_y_to_qr.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_xx_div_mod_y_to_qr (line 22) | fn demo_xx_div_mod_y_to_qr<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function benchmark_xx_div_mod_y_to_qr_algorithms (line 37) | fn benchmark_xx_div_mod_y_to_qr_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xx_sub_yy_to_zz.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_xx_sub_yy_to_zz (line 22) | fn demo_xx_sub_yy_to_zz<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function benchmark_xx_sub_yy_to_zz_algorithms (line 38) | fn benchmark_xx_sub_yy_to_zz_algorithms<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xxx_add_yyy_to_zzz.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_xxx_add_yyy_to_zzz (line 21) | fn demo_xxx_add_yyy_to_zzz<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function benchmark_xxx_add_yyy_to_zzz (line 39) | fn benchmark_xxx_add_yyy_to_zzz<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xxx_sub_yyy_to_zzz.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_xxx_sub_yyy_to_zzz (line 21) | fn demo_xxx_sub_yyy_to_zzz<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function benchmark_xxx_sub_yyy_to_zzz (line 39) | fn benchmark_xxx_sub_yyy_to_zzz<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xxxx_add_yyyy_to_zzzz.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_xxxx_add_yyyy_to_zzzz (line 21) | fn demo_xxxx_add_yyyy_to_zzzz<T: PrimitiveUnsigned>(gm: GenMode, config:...
function benchmark_xxxx_add_yyyy_to_zzzz (line 41) | fn benchmark_xxxx_add_yyyy_to_zzzz<T: PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/comparison/cmp_abs.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_cmp_abs_signed (line 31) | fn demo_cmp_abs_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConf...
function demo_partial_cmp_abs_signed (line 37) | fn demo_partial_cmp_abs_signed<T: PrimitiveSigned>(gm: GenMode, config: ...
function demo_partial_cmp_abs_primitive_float (line 48) | fn demo_partial_cmp_abs_primitive_float<T: PrimitiveFloat>(
function benchmark_cmp_abs_signed_algorithms (line 64) | fn benchmark_cmp_abs_signed_algorithms<T: PrimitiveSigned>(
function benchmark_partial_cmp_abs_signed (line 89) | fn benchmark_partial_cmp_abs_signed<T: PrimitiveSigned>(
function benchmark_partial_cmp_abs_primitive_float_algorithms (line 108) | fn benchmark_partial_cmp_abs_primitive_float_algorithms<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/comparison/eq_abs.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_eq_abs_signed (line 29) | fn demo_eq_abs_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfi...
function demo_eq_abs_primitive_float (line 39) | fn demo_eq_abs_primitive_float<T: PrimitiveFloat>(gm: GenMode, config: &...
function benchmark_eq_abs_signed_algorithms (line 50) | fn benchmark_eq_abs_signed_algorithms<T: PrimitiveSigned>(
function benchmark_eq_abs_primitive_float_algorithms (line 76) | fn benchmark_eq_abs_primitive_float_algorithms<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/comparison/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/comparison/ord_abs_comparators.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_lt_abs_signed (line 28) | fn demo_lt_abs_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfi...
function demo_gt_abs_signed (line 34) | fn demo_gt_abs_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfi...
function demo_le_abs_signed (line 40) | fn demo_le_abs_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfi...
function demo_ge_abs_signed (line 46) | fn demo_ge_abs_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfi...
function benchmark_lt_abs_signed (line 52) | fn benchmark_lt_abs_signed<T: PrimitiveSigned>(
function benchmark_gt_abs_signed (line 70) | fn benchmark_gt_abs_signed<T: PrimitiveSigned>(
function benchmark_le_abs_signed (line 88) | fn benchmark_le_abs_signed<T: PrimitiveSigned>(
function benchmark_ge_abs_signed (line 106) | fn benchmark_ge_abs_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/general_digits/from_digits.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_from_digits_asc (line 29) | fn demo_from_digits_asc<
function demo_from_digits_desc (line 51) | fn demo_from_digits_desc<
function demo_from_digits_asc_targeted (line 73) | fn demo_from_digits_asc_targeted<
function demo_from_digits_desc_targeted (line 95) | fn demo_from_digits_desc_targeted<
function benchmark_from_digits_asc (line 117) | fn benchmark_from_digits_asc<
function benchmark_from_digits_desc (line 145) | fn benchmark_from_digits_desc<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/general_digits/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/general_digits/to_digits.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_to_digits_asc (line 24) | fn demo_to_digits_asc<
function demo_to_digits_desc (line 45) | fn demo_to_digits_desc<
function benchmark_to_digits_asc (line 66) | fn benchmark_to_digits_asc<
function benchmark_to_digits_desc (line 89) | fn benchmark_to_digits_desc<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/power_of_2_digits/from_power_of_2_digits.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_from_power_of_2_digits_asc (line 29) | fn demo_from_power_of_2_digits_asc<
function demo_from_power_of_2_digits_desc (line 51) | fn demo_from_power_of_2_digits_desc<
function demo_from_power_of_2_digits_asc_targeted (line 73) | fn demo_from_power_of_2_digits_asc_targeted<
function demo_from_power_of_2_digits_desc_targeted (line 95) | fn demo_from_power_of_2_digits_desc_targeted<
function benchmark_from_power_of_2_digits_asc (line 117) | fn benchmark_from_power_of_2_digits_asc<
function benchmark_from_power_of_2_digits_desc (line 144) | fn benchmark_from_power_of_2_digits_desc<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/power_of_2_digits/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/power_of_2_digits/power_of_2_digit_iterable.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_power_of_2_digits (line 29) | fn demo_power_of_2_digits<T: PowerOf2DigitIterable<U> + PrimitiveUnsigne...
function demo_power_of_2_digits_rev (line 47) | fn demo_power_of_2_digits_rev<
function demo_power_of_2_digits_size_hint (line 70) | fn demo_power_of_2_digits_size_hint<
function demo_power_of_2_digits_get_digit (line 91) | fn demo_power_of_2_digits_get_digit<
function benchmark_power_of_2_digits_size_hint (line 113) | fn benchmark_power_of_2_digits_size_hint<
function benchmark_power_of_2_digits_get_digit_algorithms (line 140) | fn benchmark_power_of_2_digits_get_digit_algorithms<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/power_of_2_digits/to_power_of_2_digits.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_to_power_of_2_digits_asc (line 31) | fn demo_to_power_of_2_digits_asc<T: PowerOf2Digits<U> + PrimitiveUnsigne...
function demo_to_power_of_2_digits_desc (line 49) | fn demo_to_power_of_2_digits_desc<
function benchmark_to_power_of_2_digits_asc_evaluation_strategy (line 70) | fn benchmark_to_power_of_2_digits_asc_evaluation_strategy<
function benchmark_to_power_of_2_digits_desc_evaluation_strategy (line 105) | fn benchmark_to_power_of_2_digits_desc_evaluation_strategy<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/from/convertible_from.rs
function register (line 24) | pub(crate) fn register(runner: &mut Runner) {
function demo_primitive_int_convertible_from_unsigned (line 56) | fn demo_primitive_int_convertible_from_unsigned<
function demo_primitive_int_convertible_from_signed (line 74) | fn demo_primitive_int_convertible_from_signed<T: ConvertibleFrom<U> + Na...
function demo_primitive_int_convertible_from_primitive_float (line 89) | fn demo_primitive_int_convertible_from_primitive_float<
function demo_primitive_float_convertible_from_unsigned (line 107) | fn demo_primitive_float_convertible_from_unsigned<
function demo_primitive_float_convertible_from_signed (line 125) | fn demo_primitive_float_convertible_from_signed<
function benchmark_primitive_int_convertible_from_unsigned (line 143) | fn benchmark_primitive_int_convertible_from_unsigned<
function benchmark_primitive_int_convertible_from_signed (line 164) | fn benchmark_primitive_int_convertible_from_signed<
function benchmark_primitive_int_convertible_from_primitive_float (line 185) | fn benchmark_primitive_int_convertible_from_primitive_float<
function benchmark_primitive_float_convertible_from_unsigned (line 206) | fn benchmark_primitive_float_convertible_from_unsigned<
function benchmark_primitive_float_convertible_from_signed (line 227) | fn benchmark_primitive_float_convertible_from_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/from/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/from/overflowing_from.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_primitive_int_overflowing_from_unsigned (line 30) | fn demo_primitive_int_overflowing_from_unsigned<
function demo_primitive_int_overflowing_from_signed (line 48) | fn demo_primitive_int_overflowing_from_signed<
function benchmark_primitive_int_overflowing_from_unsigned (line 66) | fn benchmark_primitive_int_overflowing_from_unsigned<
function benchmark_primitive_int_overflowing_from_signed (line 87) | fn benchmark_primitive_int_overflowing_from_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/from/rounding_from.rs
function register (line 26) | pub(crate) fn register(runner: &mut Runner) {
function demo_primitive_int_rounding_from_primitive_float (line 48) | fn demo_primitive_int_rounding_from_primitive_float<
function demo_primitive_float_rounding_from_unsigned (line 70) | fn demo_primitive_float_rounding_from_unsigned<
function demo_primitive_float_rounding_from_signed (line 93) | fn demo_primitive_float_rounding_from_signed<
function benchmark_primitive_int_rounding_from_primitive_float (line 116) | fn benchmark_primitive_int_rounding_from_primitive_float<
function benchmark_primitive_float_rounding_from_unsigned (line 137) | fn benchmark_primitive_float_rounding_from_unsigned<
function benchmark_primitive_float_rounding_from_signed (line 158) | fn benchmark_primitive_float_rounding_from_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/from/saturating_from.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_primitive_int_saturating_from_unsigned (line 30) | fn demo_primitive_int_saturating_from_unsigned<
function demo_primitive_int_saturating_from_signed (line 48) | fn demo_primitive_int_saturating_from_signed<
function benchmark_primitive_int_saturating_from_unsigned (line 66) | fn benchmark_primitive_int_saturating_from_unsigned<
function benchmark_primitive_int_saturating_from_signed (line 87) | fn benchmark_primitive_int_saturating_from_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/from/try_from_and_exact_from.rs
function register (line 27) | pub(crate) fn register(runner: &mut Runner) {
function demo_primitive_int_try_from_primitive_float (line 63) | fn demo_primitive_int_try_from_primitive_float<
function demo_primitive_float_try_from_unsigned (line 79) | fn demo_primitive_float_try_from_unsigned<T: PrimitiveUnsigned, U: Primi...
function demo_primitive_float_try_from_signed (line 97) | fn demo_primitive_float_try_from_signed<T: PrimitiveSigned, U: Primitive...
function demo_primitive_int_exact_from_unsigned (line 115) | fn demo_primitive_int_exact_from_unsigned<T: TryFrom<U> + Display + Name...
function demo_primitive_int_exact_from_signed (line 125) | fn demo_primitive_int_exact_from_signed<T: TryFrom<U> + Display + Named,...
function demo_unsigned_exact_from_primitive_float (line 135) | fn demo_unsigned_exact_from_primitive_float<
function demo_signed_exact_from_primitive_float (line 154) | fn demo_signed_exact_from_primitive_float<
function demo_primitive_float_exact_from_unsigned (line 173) | fn demo_primitive_float_exact_from_unsigned<
function demo_primitive_float_exact_from_signed (line 193) | fn demo_primitive_float_exact_from_signed<
function benchmark_primitive_int_try_from_primitive_float (line 213) | fn benchmark_primitive_int_try_from_primitive_float<
function benchmark_primitive_float_try_from_unsigned (line 236) | fn benchmark_primitive_float_try_from_unsigned<T: PrimitiveFloat, U: Pri...
function benchmark_primitive_float_try_from_signed (line 258) | fn benchmark_primitive_float_try_from_signed<T: PrimitiveFloat, U: Primi...
function benchmark_primitive_int_exact_from_unsigned (line 280) | fn benchmark_primitive_int_exact_from_unsigned<T: TryFrom<U> + Named, U:...
function benchmark_primitive_int_exact_from_signed (line 298) | fn benchmark_primitive_int_exact_from_signed<T: TryFrom<U> + Named, U: P...
function benchmark_unsigned_exact_from_primitive_float (line 316) | fn benchmark_unsigned_exact_from_primitive_float<
function benchmark_signed_exact_from_primitive_float (line 339) | fn benchmark_signed_exact_from_primitive_float<
function benchmark_primitive_float_exact_from_unsigned (line 362) | fn benchmark_primitive_float_exact_from_unsigned<
function benchmark_primitive_float_exact_from_signed (line 385) | fn benchmark_primitive_float_exact_from_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/from/wrapping_from.rs
function register (line 20) | pub(crate) fn register(runner: &mut Runner) {
function demo_primitive_int_wrapping_from_unsigned (line 30) | fn demo_primitive_int_wrapping_from_unsigned<
function demo_primitive_int_wrapping_from_signed (line 48) | fn demo_primitive_int_wrapping_from_signed<
function benchmark_primitive_int_wrapping_from_unsigned (line 66) | fn benchmark_primitive_int_wrapping_from_unsigned<
function benchmark_primitive_int_wrapping_from_signed (line 87) | fn benchmark_primitive_int_wrapping_from_signed<T: WrappingFrom<U> + Nam...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/half/join_halves.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_join_halves (line 23) | fn demo_join_halves<T: JoinHalves + PrimitiveUnsigned>(
function benchmark_join_halves (line 44) | fn benchmark_join_halves<T: JoinHalves + PrimitiveUnsigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/half/lower_half.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_lower_half (line 22) | fn demo_lower_half<T: PrimitiveUnsigned + SplitInHalf>(
function benchmark_lower_half (line 34) | fn benchmark_lower_half<T: PrimitiveUnsigned + SplitInHalf>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/half/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/half/split_in_half.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_split_in_half (line 22) | fn demo_split_in_half<T: PrimitiveUnsigned + SplitInHalf>(
function benchmark_split_in_half (line 34) | fn benchmark_split_in_half<T: PrimitiveUnsigned + SplitInHalf>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/half/upper_half.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_upper_half (line 22) | fn demo_upper_half<T: PrimitiveUnsigned + SplitInHalf>(
function benchmark_upper_half (line 34) | fn benchmark_upper_half<T: PrimitiveUnsigned + SplitInHalf>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/is_integer.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_is_integer_primitive_float (line 30) | fn demo_is_integer_primitive_float<T: PrimitiveFloat>(
function demo_is_integer_unsigned (line 44) | fn demo_is_integer_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_is_integer_signed (line 54) | fn demo_is_integer_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function benchmark_is_integer_primitive_float (line 64) | fn benchmark_is_integer_primitive_float<T: PrimitiveFloat>(
function benchmark_is_integer_unsigned (line 82) | fn benchmark_is_integer_unsigned<T: PrimitiveUnsigned>(
function benchmark_is_integer_signed (line 100) | fn benchmark_is_integer_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/mantissa_and_exponent/integer_mantissa_and_exponent.rs
function register (line 23) | pub(crate) fn register(runner: &mut Runner) {
function demo_integer_mantissa_and_exponent_unsigned (line 82) | fn demo_integer_mantissa_and_exponent_unsigned<T: PrimitiveUnsigned>(
function demo_integer_mantissa_unsigned (line 96) | fn demo_integer_mantissa_unsigned<T: PrimitiveUnsigned>(
function demo_integer_exponent_unsigned (line 106) | fn demo_integer_exponent_unsigned<T: PrimitiveUnsigned>(
function demo_from_integer_mantissa_and_exponent_unsigned (line 116) | fn demo_from_integer_mantissa_and_exponent_unsigned<T: PrimitiveUnsigned>(
function demo_from_integer_mantissa_and_exponent_targeted_unsigned (line 135) | fn demo_from_integer_mantissa_and_exponent_targeted_unsigned<T: Primitiv...
function demo_integer_mantissa_and_exponent_primitive_float (line 151) | fn demo_integer_mantissa_and_exponent_primitive_float<T: PrimitiveFloat>(
function demo_integer_mantissa_primitive_float (line 168) | fn demo_integer_mantissa_primitive_float<T: PrimitiveFloat>(
function demo_integer_exponent_primitive_float (line 185) | fn demo_integer_exponent_primitive_float<T: PrimitiveFloat>(
function demo_from_integer_mantissa_and_exponent_primitive_float (line 202) | fn demo_from_integer_mantissa_and_exponent_primitive_float<T: PrimitiveF...
function demo_from_integer_mantissa_and_exponent_targeted_primitive_float (line 218) | fn demo_from_integer_mantissa_and_exponent_targeted_primitive_float<T: P...
function benchmark_integer_mantissa_and_exponent_algorithms_unsigned (line 238) | fn benchmark_integer_mantissa_and_exponent_algorithms_unsigned<T: Primit...
function benchmark_integer_mantissa_algorithms_unsigned (line 264) | fn benchmark_integer_mantissa_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_integer_exponent_algorithms_unsigned (line 286) | fn benchmark_integer_exponent_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_from_integer_mantissa_and_exponent_unsigned (line 307) | fn benchmark_from_integer_mantissa_and_exponent_unsigned<T: PrimitiveUns...
function benchmark_from_integer_mantissa_and_exponent_targeted_unsigned (line 331) | fn benchmark_from_integer_mantissa_and_exponent_targeted_unsigned<T: Pri...
function benchmark_integer_mantissa_and_exponent_algorithms_primitive_float (line 356) | fn benchmark_integer_mantissa_and_exponent_algorithms_primitive_float<T:...
function benchmark_integer_mantissa_algorithms_primitive_float (line 382) | fn benchmark_integer_mantissa_algorithms_primitive_float<T: PrimitiveFlo...
function benchmark_integer_exponent_algorithms_primitive_float (line 404) | fn benchmark_integer_exponent_algorithms_primitive_float<T: PrimitiveFlo...
function benchmark_from_integer_mantissa_and_exponent_primitive_float (line 425) | fn benchmark_from_integer_mantissa_and_exponent_primitive_float<T: Primi...
function benchmark_from_integer_mantissa_and_exponent_targeted_primitive_float (line 445) | fn benchmark_from_integer_mantissa_and_exponent_targeted_primitive_float...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/mantissa_and_exponent/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/mantissa_and_exponent/raw_mantissa_and_exponent.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_raw_mantissa_and_exponent (line 28) | fn demo_raw_mantissa_and_exponent<T: PrimitiveFloat>(
function demo_raw_mantissa (line 42) | fn demo_raw_mantissa<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig,...
function demo_raw_exponent (line 48) | fn demo_raw_exponent<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig,...
function demo_from_raw_mantissa_and_exponent (line 54) | fn demo_from_raw_mantissa_and_exponent<T: PrimitiveFloat>(
function benchmark_raw_mantissa_and_exponent_algorithms (line 71) | fn benchmark_raw_mantissa_and_exponent_algorithms<T: PrimitiveFloat>(
function benchmark_raw_mantissa_algorithms (line 95) | fn benchmark_raw_mantissa_algorithms<T: PrimitiveFloat>(
function benchmark_raw_exponent_algorithms (line 117) | fn benchmark_raw_exponent_algorithms<T: PrimitiveFloat>(
function benchmark_from_raw_mantissa_and_exponent (line 138) | fn benchmark_from_raw_mantissa_and_exponent<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/mantissa_and_exponent/sci_mantissa_and_exponent.rs
function register (line 32) | pub(crate) fn register(runner: &mut Runner) {
function demo_sci_mantissa_and_exponent_unsigned (line 96) | fn demo_sci_mantissa_and_exponent_unsigned<
function demo_sci_mantissa_unsigned (line 110) | fn demo_sci_mantissa_unsigned<
function demo_sci_exponent_unsigned (line 124) | fn demo_sci_exponent_unsigned<
function demo_sci_mantissa_and_exponent_round (line 141) | fn demo_sci_mantissa_and_exponent_round<
function demo_from_sci_mantissa_and_exponent_unsigned (line 159) | fn demo_from_sci_mantissa_and_exponent_unsigned<
function demo_from_sci_mantissa_and_exponent_targeted_unsigned (line 181) | fn demo_from_sci_mantissa_and_exponent_targeted_unsigned<
function demo_from_sci_mantissa_and_exponent_round (line 203) | fn demo_from_sci_mantissa_and_exponent_round<T: PrimitiveUnsigned, U: Pr...
function demo_from_sci_mantissa_and_exponent_round_targeted (line 223) | fn demo_from_sci_mantissa_and_exponent_round_targeted<T: PrimitiveUnsign...
function demo_sci_mantissa_and_exponent_primitive_float (line 242) | fn demo_sci_mantissa_and_exponent_primitive_float<T: PrimitiveFloat>(
function demo_sci_mantissa_primitive_float (line 260) | fn demo_sci_mantissa_primitive_float<T: PrimitiveFloat>(
function demo_sci_exponent_primitive_float (line 277) | fn demo_sci_exponent_primitive_float<T: PrimitiveFloat>(
function demo_from_sci_mantissa_and_exponent_primitive_float (line 290) | fn demo_from_sci_mantissa_and_exponent_primitive_float<T: PrimitiveFloat>(
function demo_from_sci_mantissa_and_exponent_targeted_primitive_float (line 309) | fn demo_from_sci_mantissa_and_exponent_targeted_primitive_float<T: Primi...
function benchmark_sci_mantissa_and_exponent_algorithms_unsigned (line 329) | fn benchmark_sci_mantissa_and_exponent_algorithms_unsigned<
function benchmark_sci_mantissa_algorithms_unsigned (line 363) | fn benchmark_sci_mantissa_algorithms_unsigned<
function benchmark_sci_exponent_algorithms_unsigned (line 392) | fn benchmark_sci_exponent_algorithms_unsigned<
function benchmark_from_sci_mantissa_and_exponent_unsigned (line 420) | fn benchmark_from_sci_mantissa_and_exponent_unsigned<
function benchmark_from_sci_mantissa_and_exponent_targeted_unsigned (line 447) | fn benchmark_from_sci_mantissa_and_exponent_targeted_unsigned<
function benchmark_from_sci_mantissa_and_exponent_round (line 474) | fn benchmark_from_sci_mantissa_and_exponent_round<T: PrimitiveUnsigned, ...
function benchmark_from_sci_mantissa_and_exponent_round_targeted (line 499) | fn benchmark_from_sci_mantissa_and_exponent_round_targeted<
function benchmark_sci_mantissa_and_exponent_algorithms_primitive_float (line 528) | fn benchmark_sci_mantissa_and_exponent_algorithms_primitive_float<T: Pri...
function benchmark_sci_mantissa_algorithms_primitive_float (line 552) | fn benchmark_sci_mantissa_algorithms_primitive_float<T: PrimitiveFloat>(
function benchmark_sci_exponent_algorithms_primitive_float (line 574) | fn benchmark_sci_exponent_algorithms_primitive_float<T: PrimitiveFloat>(
function benchmark_from_sci_mantissa_and_exponent_primitive_float (line 595) | fn benchmark_from_sci_mantissa_and_exponent_primitive_float<T: Primitive...
function benchmark_from_sci_mantissa_and_exponent_targeted_primitive_float (line 619) | fn benchmark_from_sci_mantissa_and_exponent_targeted_primitive_float<T: ...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/slice/from_other_type_slice.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_from_other_type_slice (line 24) | fn demo_from_other_type_slice<T: Display + FromOtherTypeSlice<U> + Named...
function benchmark_from_other_type_slice (line 39) | fn benchmark_from_other_type_slice<T: FromOtherTypeSlice<U> + Named, U: ...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/slice/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/slice/vec_from_other_type.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_vec_from_other_type (line 24) | fn demo_vec_from_other_type<T: Debug + VecFromOtherType<U> + Named, U: P...
function benchmark_vec_from_other_type (line 39) | fn benchmark_vec_from_other_type<T: VecFromOtherType<U> + Named, U: Prim...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/slice/vec_from_other_type_slice.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_vec_from_other_type_slice (line 24) | fn demo_vec_from_other_type_slice<
function benchmark_vec_from_other_type_slice (line 42) | fn benchmark_vec_from_other_type_slice<
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/from_sci_string.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_primitive_int_from_sci_string (line 34) | fn demo_primitive_int_from_sci_string<T: PrimitiveInt>(
function demo_primitive_int_from_sci_string_targeted (line 49) | fn demo_primitive_int_from_sci_string_targeted<T: PrimitiveInt>(
function demo_primitive_int_from_sci_string_with_options (line 64) | fn demo_primitive_int_from_sci_string_with_options<T: PrimitiveInt>(
function demo_primitive_int_from_sci_string_with_options_targeted (line 83) | fn demo_primitive_int_from_sci_string_with_options_targeted<T: Primitive...
function benchmark_primitive_int_from_sci_string (line 102) | fn benchmark_primitive_int_from_sci_string<T: PrimitiveInt>(
function benchmark_primitive_int_from_sci_string_with_options (line 120) | fn benchmark_primitive_int_from_sci_string_with_options<T: PrimitiveInt>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/from_string.rs
function register (line 14) | pub(crate) fn register(runner: &mut Runner) {
function demo_digit_from_display_byte (line 19) | fn demo_digit_from_display_byte(gm: GenMode, config: &GenConfig, limit: ...
function demo_digit_from_display_byte_targeted (line 29) | fn demo_digit_from_display_byte_targeted(gm: GenMode, config: &GenConfig...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/options/from_sci_string_options.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_from_sci_string_options_to_debug_string (line 24) | fn demo_from_sci_string_options_to_debug_string(gm: GenMode, config: &Ge...
function demo_from_sci_string_options_get_base (line 30) | fn demo_from_sci_string_options_get_base(gm: GenMode, config: &GenConfig...
function demo_from_sci_string_options_get_rounding_mode (line 36) | fn demo_from_sci_string_options_get_rounding_mode(gm: GenMode, config: &...
function demo_from_sci_string_options_set_base (line 46) | fn demo_from_sci_string_options_set_base(gm: GenMode, config: &GenConfig...
function demo_from_sci_string_options_set_rounding_mode (line 57) | fn demo_from_sci_string_options_set_rounding_mode(gm: GenMode, config: &...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/options/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/options/sci_size_options.rs
function register (line 13) | pub(crate) fn register(runner: &mut Runner) {
function demo_sci_size_options_to_debug_string (line 17) | fn demo_sci_size_options_to_debug_string(gm: GenMode, config: &GenConfig...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/options/to_sci_options.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_to_sci_options_to_debug_string (line 41) | fn demo_to_sci_options_to_debug_string(gm: GenMode, config: &GenConfig, ...
function demo_to_sci_options_get_base (line 47) | fn demo_to_sci_options_get_base(gm: GenMode, config: &GenConfig, limit: ...
function demo_to_sci_options_get_rounding_mode (line 53) | fn demo_to_sci_options_get_rounding_mode(gm: GenMode, config: &GenConfig...
function demo_to_sci_options_get_size_options (line 63) | fn demo_to_sci_options_get_size_options(gm: GenMode, config: &GenConfig,...
function demo_to_sci_options_get_neg_exp_threshold (line 73) | fn demo_to_sci_options_get_neg_exp_threshold(gm: GenMode, config: &GenCo...
function demo_to_sci_options_get_lowercase (line 83) | fn demo_to_sci_options_get_lowercase(gm: GenMode, config: &GenConfig, li...
function demo_to_sci_options_get_e_lowercase (line 89) | fn demo_to_sci_options_get_e_lowercase(gm: GenMode, config: &GenConfig, ...
function demo_to_sci_options_get_force_exponent_plus_sign (line 99) | fn demo_to_sci_options_get_force_exponent_plus_sign(gm: GenMode, config:...
function demo_to_sci_options_get_include_trailing_zeros (line 109) | fn demo_to_sci_options_get_include_trailing_zeros(gm: GenMode, config: &...
function demo_to_sci_options_set_base (line 119) | fn demo_to_sci_options_set_base(gm: GenMode, config: &GenConfig, limit: ...
function demo_to_sci_options_set_rounding_mode (line 130) | fn demo_to_sci_options_set_rounding_mode(gm: GenMode, config: &GenConfig...
function demo_to_sci_options_set_size_complete (line 143) | fn demo_to_sci_options_set_size_complete(gm: GenMode, config: &GenConfig...
function demo_to_sci_options_set_precision (line 151) | fn demo_to_sci_options_set_precision(gm: GenMode, config: &GenConfig, li...
function demo_to_sci_options_set_scale (line 164) | fn demo_to_sci_options_set_scale(gm: GenMode, config: &GenConfig, limit:...
function demo_to_sci_options_set_neg_exp_threshold (line 175) | fn demo_to_sci_options_set_neg_exp_threshold(gm: GenMode, config: &GenCo...
function demo_to_sci_options_set_lowercase (line 189) | fn demo_to_sci_options_set_lowercase(gm: GenMode, config: &GenConfig, li...
function demo_to_sci_options_set_uppercase (line 197) | fn demo_to_sci_options_set_uppercase(gm: GenMode, config: &GenConfig, li...
function demo_to_sci_options_set_e_lowercase (line 205) | fn demo_to_sci_options_set_e_lowercase(gm: GenMode, config: &GenConfig, ...
function demo_to_sci_options_set_e_uppercase (line 213) | fn demo_to_sci_options_set_e_uppercase(gm: GenMode, config: &GenConfig, ...
function demo_to_sci_options_set_force_exponent_plus_sign (line 221) | fn demo_to_sci_options_set_force_exponent_plus_sign(gm: GenMode, config:...
function demo_to_sci_options_set_include_trailing_zeros (line 235) | fn demo_to_sci_options_set_include_trailing_zeros(gm: GenMode, config: &...
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/to_sci.rs
function register (line 22) | pub(crate) fn register(runner: &mut Runner) {
function demo_to_sci_unsigned (line 38) | fn demo_to_sci_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &GenC...
function demo_to_sci_signed (line 44) | fn demo_to_sci_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfi...
function demo_fmt_sci_valid_unsigned (line 50) | fn demo_fmt_sci_valid_unsigned<T: PrimitiveUnsigned>(
function demo_fmt_sci_valid_signed (line 67) | fn demo_fmt_sci_valid_signed<T: PrimitiveSigned>(gm: GenMode, config: &G...
function demo_to_sci_with_options_unsigned (line 80) | fn demo_to_sci_with_options_unsigned<T: PrimitiveUnsigned>(
function demo_to_sci_with_options_signed (line 98) | fn demo_to_sci_with_options_signed<T: PrimitiveSigned>(
function benchmark_to_sci_unsigned (line 116) | fn benchmark_to_sci_unsigned<T: PrimitiveUnsigned>(
function benchmark_to_sci_signed (line 134) | fn benchmark_to_sci_signed<T: PrimitiveSigned>(
function benchmark_fmt_sci_valid_unsigned (line 152) | fn benchmark_fmt_sci_valid_unsigned<T: PrimitiveUnsigned>(
function benchmark_fmt_sci_valid_signed (line 172) | fn benchmark_fmt_sci_valid_signed<T: PrimitiveSigned>(
function benchmark_to_sci_with_options_unsigned (line 192) | fn benchmark_to_sci_with_options_unsigned<T: PrimitiveUnsigned>(
function benchmark_to_sci_with_options_signed (line 212) | fn benchmark_to_sci_with_options_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/conversion/string/to_string.rs
function register (line 29) | pub(crate) fn register(runner: &mut Runner) {
function demo_digit_to_display_byte_lower (line 63) | fn demo_digit_to_display_byte_lower(gm: GenMode, config: &GenConfig, lim...
function demo_digit_to_display_byte_upper (line 73) | fn demo_digit_to_display_byte_upper(gm: GenMode, config: &GenConfig, lim...
function demo_digit_to_display_byte_lower_targeted (line 83) | fn demo_digit_to_display_byte_lower_targeted(gm: GenMode, config: &GenCo...
function demo_digit_to_display_byte_upper_targeted (line 93) | fn demo_digit_to_display_byte_upper_targeted(gm: GenMode, config: &GenCo...
function demo_to_string_base_unsigned (line 103) | fn demo_to_string_base_unsigned<T: PrimitiveUnsigned>(
function demo_to_string_base_signed (line 121) | fn demo_to_string_base_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function demo_to_string_base_upper_unsigned (line 135) | fn demo_to_string_base_upper_unsigned<T: PrimitiveUnsigned>(
function demo_to_string_base_upper_signed (line 153) | fn demo_to_string_base_upper_signed<T: PrimitiveSigned>(
function demo_base_fmt_wrapper_fmt_unsigned (line 172) | fn demo_base_fmt_wrapper_fmt_unsigned<T: PrimitiveUnsigned>(
function demo_base_fmt_wrapper_fmt_with_width_unsigned (line 193) | fn demo_base_fmt_wrapper_fmt_with_width_unsigned<T: PrimitiveUnsigned>(
function demo_base_fmt_wrapper_fmt_signed (line 215) | fn demo_base_fmt_wrapper_fmt_signed<T: PrimitiveSigned>(
function demo_base_fmt_wrapper_fmt_with_width_signed (line 236) | fn demo_base_fmt_wrapper_fmt_with_width_signed<T: PrimitiveSigned>(
function demo_base_fmt_wrapper_fmt_upper_unsigned (line 258) | fn demo_base_fmt_wrapper_fmt_upper_unsigned<T: PrimitiveUnsigned>(
function demo_base_fmt_wrapper_fmt_upper_with_width_unsigned (line 279) | fn demo_base_fmt_wrapper_fmt_upper_with_width_unsigned<T: PrimitiveUnsig...
function demo_base_fmt_wrapper_fmt_upper_signed (line 301) | fn demo_base_fmt_wrapper_fmt_upper_signed<T: PrimitiveSigned>(
function demo_base_fmt_wrapper_fmt_upper_with_width_signed (line 322) | fn demo_base_fmt_wrapper_fmt_upper_with_width_signed<T: PrimitiveSigned>(
function benchmark_to_string_base_algorithms_unsigned (line 344) | fn benchmark_to_string_base_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_to_string_base_algorithms_signed (line 376) | fn benchmark_to_string_base_algorithms_signed<T: PrimitiveSigned>(
function benchmark_to_string_base_upper_algorithms_unsigned (line 409) | fn benchmark_to_string_base_upper_algorithms_unsigned<T: PrimitiveUnsign...
function benchmark_to_string_base_upper_algorithms_signed (line 437) | fn benchmark_to_string_base_upper_algorithms_signed<T: PrimitiveSigned>(
function benchmark_base_fmt_wrapper_fmt_with_width_unsigned (line 465) | fn benchmark_base_fmt_wrapper_fmt_with_width_unsigned<T: PrimitiveUnsign...
function benchmark_base_fmt_wrapper_fmt_with_width_signed (line 495) | fn benchmark_base_fmt_wrapper_fmt_with_width_signed<T: PrimitiveSigned>(
function benchmark_base_fmt_wrapper_fmt_upper_with_width_unsigned (line 525) | fn benchmark_base_fmt_wrapper_fmt_upper_with_width_unsigned<T: Primitive...
function benchmark_base_fmt_wrapper_fmt_upper_with_width_signed (line 555) | fn benchmark_base_fmt_wrapper_fmt_upper_with_width_signed<T: PrimitiveSi...
FILE: malachite-base/src/bin_util/demo_and_bench/num/factorization/factor.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_factor_helper (line 35) | fn demo_factor_helper<T: Factor + PrimitiveUnsigned>(u: T)
function demo_u8_factor (line 56) | fn demo_u8_factor(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_u16_factor (line 62) | fn demo_u16_factor(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_u32_factor (line 68) | fn demo_u32_factor(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_u64_factor (line 74) | fn demo_u64_factor(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_usize_factor (line 80) | fn demo_usize_factor(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_u8_factor_algorithms (line 86) | fn benchmark_u8_factor_algorithms(gm: GenMode, config: &GenConfig, limit...
function benchmark_u16_factor_algorithms (line 112) | fn benchmark_u16_factor_algorithms(gm: GenMode, config: &GenConfig, limi...
function benchmark_u32_factor (line 138) | fn benchmark_u32_factor(gm: GenMode, config: &GenConfig, limit: usize, f...
function benchmark_u32_factor_algorithms (line 156) | fn benchmark_u32_factor_algorithms(gm: GenMode, config: &GenConfig, limi...
function benchmark_u64_factor (line 182) | fn benchmark_u64_factor(gm: GenMode, config: &GenConfig, limit: usize, f...
function benchmark_u64_factor_algorithms (line 200) | fn benchmark_u64_factor_algorithms(gm: GenMode, config: &GenConfig, limi...
function benchmark_usize_factor_algorithms (line 226) | fn benchmark_usize_factor_algorithms(
FILE: malachite-base/src/bin_util/demo_and_bench/num/factorization/is_power.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_express_as_power_unsigned (line 29) | fn demo_express_as_power_unsigned<T: PrimitiveUnsigned>(
function demo_express_as_power_signed (line 39) | fn demo_express_as_power_signed<T: PrimitiveSigned>(gm: GenMode, config:...
function demo_is_power_unsigned (line 45) | fn demo_is_power_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Ge...
function demo_is_power_signed (line 55) | fn demo_is_power_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenCon...
function benchmark_express_as_power_unsigned (line 65) | fn benchmark_express_as_power_unsigned<T: PrimitiveUnsigned>(
function benchmark_express_as_power_signed (line 83) | fn benchmark_express_as_power_signed<T: PrimitiveSigned>(
function benchmark_is_power_unsigned_algorithms (line 102) | fn benchmark_is_power_unsigned_algorithms<T: PrimitiveUnsigned>(
function benchmark_is_power_signed_algorithms (line 126) | fn benchmark_is_power_signed_algorithms<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/factorization/is_prime.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_u8_is_prime (line 33) | fn demo_u8_is_prime(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_u16_is_prime (line 43) | fn demo_u16_is_prime(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_u32_is_prime (line 53) | fn demo_u32_is_prime(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_u64_is_prime (line 63) | fn demo_u64_is_prime(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_usize_is_prime (line 73) | fn demo_usize_is_prime(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_u8_is_prime_algorithms (line 83) | fn benchmark_u8_is_prime_algorithms(
function benchmark_u16_is_prime_algorithms (line 104) | fn benchmark_u16_is_prime_algorithms(
function benchmark_u32_is_prime (line 125) | fn benchmark_u32_is_prime(gm: GenMode, config: &GenConfig, limit: usize,...
function benchmark_u32_is_prime_algorithms (line 143) | fn benchmark_u32_is_prime_algorithms(
function benchmark_u64_is_prime (line 174) | fn benchmark_u64_is_prime(gm: GenMode, config: &GenConfig, limit: usize,...
function benchmark_u64_is_prime_algorithms (line 192) | fn benchmark_u64_is_prime_algorithms(
function benchmark_usize_is_prime_algorithms (line 223) | fn benchmark_usize_is_prime_algorithms(
FILE: malachite-base/src/bin_util/demo_and_bench/num/factorization/is_square.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_is_square_unsigned (line 25) | fn demo_is_square_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_is_square_signed (line 35) | fn demo_is_square_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenCo...
function benchmark_is_square_unsigned_algorithms (line 46) | fn benchmark_is_square_unsigned_algorithms<T: PrimitiveUnsigned>(
function benchmark_is_square_signed_algorithms (line 68) | fn benchmark_is_square_signed_algorithms<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/factorization/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/factorization/prime_sieve.rs
function register (line 21) | pub(crate) fn register(runner: &mut Runner) {
function demo_limbs_prime_sieve_u32 (line 28) | fn demo_limbs_prime_sieve_u32(gm: GenMode, config: &GenConfig, limit: us...
function demo_limbs_prime_sieve_u64 (line 47) | fn demo_limbs_prime_sieve_u64(gm: GenMode, config: &GenConfig, limit: us...
function benchmark_limbs_prime_sieve_u32_algorithms (line 66) | fn benchmark_limbs_prime_sieve_u32_algorithms(
function benchmark_limbs_prime_sieve_u64_algorithms (line 100) | fn benchmark_limbs_prime_sieve_u64_algorithms(
FILE: malachite-base/src/bin_util/demo_and_bench/num/factorization/primes.rs
function register (line 24) | pub(crate) fn register(runner: &mut Runner) {
function demo_primes_less_than (line 79) | fn demo_primes_less_than<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_primes_less_than_or_equal_to (line 89) | fn demo_primes_less_than_or_equal_to<T: PrimitiveUnsigned>(
function demo_primes (line 103) | fn demo_primes<T: PrimitiveUnsigned>(_gm: GenMode, _config: &GenConfig, ...
function demo_prime_indicator_sequence_less_than (line 109) | fn demo_prime_indicator_sequence_less_than(gm: GenMode, config: &GenConf...
function demo_prime_indicator_sequence_less_than_or_equal_to (line 119) | fn demo_prime_indicator_sequence_less_than_or_equal_to(
function demo_prime_indicator_sequence (line 133) | fn demo_prime_indicator_sequence(_gm: GenMode, _config: &GenConfig, limi...
function demo_primes_less_than_jump_after (line 139) | fn demo_primes_less_than_jump_after<T: PrimitiveUnsigned>(
function demo_primes_jump_after (line 169) | fn demo_primes_jump_after<T: PrimitiveUnsigned>(gm: GenMode, config: &Ge...
function benchmark_primes_less_than_algorithms (line 191) | fn benchmark_primes_less_than_algorithms<T: PrimitiveUnsigned>(
function benchmark_primes_less_than_algorithms_2 (line 219) | fn benchmark_primes_less_than_algorithms_2<T: PrimitiveUnsigned>(
function benchmark_primes_less_than_or_equal_to_algorithms (line 244) | fn benchmark_primes_less_than_or_equal_to_algorithms<T: PrimitiveUnsigned>(
function benchmark_primes_less_than_or_equal_to_algorithms_2 (line 274) | fn benchmark_primes_less_than_or_equal_to_algorithms_2<T: PrimitiveUnsig...
function benchmark_prime_indicator_sequence_less_than (line 301) | fn benchmark_prime_indicator_sequence_less_than(
function benchmark_prime_indicator_sequence_less_than_or_equal_to (line 321) | fn benchmark_prime_indicator_sequence_less_than_or_equal_to(
FILE: malachite-base/src/bin_util/demo_and_bench/num/factorization/primitive_root_prime.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_u8_primitive_root_prime (line 30) | fn demo_u8_primitive_root_prime(gm: GenMode, config: &GenConfig, limit: ...
function demo_u16_primitive_root_prime (line 36) | fn demo_u16_primitive_root_prime(gm: GenMode, config: &GenConfig, limit:...
function demo_u32_primitive_root_prime (line 42) | fn demo_u32_primitive_root_prime(gm: GenMode, config: &GenConfig, limit:...
function demo_u64_primitive_root_prime (line 48) | fn demo_u64_primitive_root_prime(gm: GenMode, config: &GenConfig, limit:...
function demo_usize_primitive_root_prime (line 54) | fn demo_usize_primitive_root_prime(gm: GenMode, config: &GenConfig, limi...
function benchmark_u8_primitive_root_prime (line 60) | fn benchmark_u8_primitive_root_prime(
function benchmark_u16_primitive_root_prime (line 78) | fn benchmark_u16_primitive_root_prime(
function benchmark_u32_primitive_root_prime (line 96) | fn benchmark_u32_primitive_root_prime(
function benchmark_u64_primitive_root_prime (line 114) | fn benchmark_u64_primitive_root_prime(
function benchmark_usize_primitive_root_prime (line 132) | fn benchmark_usize_primitive_root_prime(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/abs_negative_zero.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_abs_negative_zero (line 24) | fn demo_abs_negative_zero<T: PrimitiveFloat>(gm: GenMode, config: &GenCo...
function demo_abs_negative_zero_assign (line 34) | fn demo_abs_negative_zero_assign<T: PrimitiveFloat>(gm: GenMode, config:...
function benchmark_abs_negative_zero (line 46) | fn benchmark_abs_negative_zero<T: PrimitiveFloat>(
function benchmark_abs_negative_zero_assign (line 64) | fn benchmark_abs_negative_zero_assign<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/from_ordered_representation.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_from_ordered_representation (line 22) | fn demo_from_ordered_representation<T: PrimitiveFloat>(
function benchmark_from_ordered_representation (line 36) | fn benchmark_from_ordered_representation<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/is_negative_zero.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_is_negative_zero (line 22) | fn demo_is_negative_zero<T: PrimitiveFloat>(gm: GenMode, config: &GenCon...
function benchmark_is_negative_zero (line 32) | fn benchmark_is_negative_zero<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/max_precision_for_sci_exponent.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_max_precision_for_sci_exponent (line 21) | fn demo_max_precision_for_sci_exponent<T: PrimitiveFloat>(
function benchmark_max_precision_for_sci_exponent (line 35) | fn benchmark_max_precision_for_sci_exponent<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/next_higher.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_next_higher (line 22) | fn demo_next_higher<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig, ...
function benchmark_next_higher (line 32) | fn benchmark_next_higher<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/next_lower.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_next_lower (line 22) | fn demo_next_lower<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig, l...
function benchmark_next_lower (line 35) | fn benchmark_next_lower<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/precision.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_precision (line 22) | fn demo_precision<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig, li...
function benchmark_precision (line 31) | fn benchmark_precision<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/basic/to_ordered_representation.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_to_ordered_representation (line 22) | fn demo_to_ordered_representation<T: PrimitiveFloat>(
function benchmark_to_ordered_representation (line 39) | fn benchmark_to_ordered_representation<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/nice_float/cmp.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_nice_float_cmp (line 24) | fn demo_nice_float_cmp<T: PrimitiveFloat>(gm: GenMode, config: &GenConfi...
function benchmark_nice_float_cmp_algorithms (line 37) | fn benchmark_nice_float_cmp_algorithms<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/nice_float/cmp_abs.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_nice_float_cmp_abs (line 24) | fn demo_nice_float_cmp_abs<T: PrimitiveFloat>(gm: GenMode, config: &GenC...
function benchmark_nice_float_cmp_abs_algorithms (line 37) | fn benchmark_nice_float_cmp_abs_algorithms<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/nice_float/eq.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_nice_float_eq (line 22) | fn demo_nice_float_eq<T: PrimitiveFloat>(gm: GenMode, config: &GenConfig...
function benchmark_nice_float_eq_algorithms (line 35) | fn benchmark_nice_float_eq_algorithms<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/nice_float/eq_abs.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_nice_float_eq_abs (line 23) | fn demo_nice_float_eq_abs<T: PrimitiveFloat>(gm: GenMode, config: &GenCo...
function benchmark_nice_float_eq_abs_algorithms (line 36) | fn benchmark_nice_float_eq_abs_algorithms<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/nice_float/from_str.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_nice_float_from_str (line 25) | fn demo_nice_float_from_str<T: PrimitiveFloat>(gm: GenMode, config: &Gen...
function demo_nice_float_from_str_targeted (line 38) | fn demo_nice_float_from_str_targeted<T: PrimitiveFloat>(
function benchmark_nice_float_from_str (line 55) | fn benchmark_nice_float_from_str<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/nice_float/hash.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_nice_float_hash (line 23) | fn demo_nice_float_hash<T: PrimitiveFloat>(gm: GenMode, config: &GenConf...
function benchmark_nice_float_hash (line 30) | fn benchmark_nice_float_hash<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/nice_float/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/float/nice_float/to_string.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_nice_float_to_string (line 22) | fn demo_nice_float_to_string<T: PrimitiveFloat>(gm: GenMode, config: &Ge...
function benchmark_nice_float_to_string_algorithms (line 28) | fn benchmark_nice_float_to_string_algorithms<T: PrimitiveFloat>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_access/assign_bit.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_assign_bit_unsigned (line 26) | fn demo_assign_bit_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_assign_bit_signed (line 37) | fn demo_assign_bit_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function benchmark_assign_bit_unsigned (line 48) | fn benchmark_assign_bit_unsigned<T: PrimitiveUnsigned>(
function benchmark_assign_bit_signed (line 68) | fn benchmark_assign_bit_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_access/clear_bit.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_clear_bit_unsigned (line 26) | fn demo_clear_bit_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &G...
function demo_clear_bit_signed (line 37) | fn demo_clear_bit_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenCo...
function benchmark_clear_bit_unsigned (line 48) | fn benchmark_clear_bit_unsigned<T: PrimitiveUnsigned>(
function benchmark_clear_bit_signed (line 66) | fn benchmark_clear_bit_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_access/flip_bit.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_flip_bit_unsigned (line 26) | fn demo_flip_bit_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Ge...
function demo_flip_bit_signed (line 34) | fn demo_flip_bit_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenCon...
function benchmark_flip_bit_unsigned (line 45) | fn benchmark_flip_bit_unsigned<T: PrimitiveUnsigned>(
function benchmark_flip_bit_signed (line 63) | fn benchmark_flip_bit_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_access/get_bit.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_get_bit_unsigned (line 26) | fn demo_get_bit_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_get_bit_signed (line 35) | fn demo_get_bit_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConf...
function benchmark_get_bit_unsigned (line 44) | fn benchmark_get_bit_unsigned<T: PrimitiveUnsigned>(
function benchmark_get_bit_signed (line 62) | fn benchmark_get_bit_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_access/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_access/set_bit.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_set_bit_unsigned (line 26) | fn demo_set_bit_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Gen...
function demo_set_bit_signed (line 34) | fn demo_set_bit_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConf...
function benchmark_set_bit_unsigned (line 45) | fn benchmark_set_bit_unsigned<T: PrimitiveUnsigned>(
function benchmark_set_bit_signed (line 63) | fn benchmark_set_bit_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_block_access/assign_bits.rs
function register (line 22) | pub(crate) fn register(runner: &mut Runner) {
function demo_assign_bits_unsigned (line 29) | fn demo_assign_bits_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: ...
function demo_assign_bits_signed (line 43) | fn demo_assign_bits_signed<
function benchmark_assign_bits_algorithms_unsigned (line 61) | fn benchmark_assign_bits_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_assign_bits_algorithms_signed (line 88) | fn benchmark_assign_bits_algorithms_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_block_access/get_bits.rs
function register (line 22) | pub(crate) fn register(runner: &mut Runner) {
function demo_get_bits_unsigned (line 29) | fn demo_get_bits_unsigned<T: BitBlockAccess<Bits = T> + PrimitiveUnsigned>(
function demo_get_bits_signed (line 48) | fn demo_get_bits_signed<
function benchmark_get_bits_algorithms_unsigned (line 72) | fn benchmark_get_bits_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_get_bits_algorithms_signed (line 97) | fn benchmark_get_bits_algorithms_signed<
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_block_access/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_convertible/from_bits.rs
function register (line 22) | pub(crate) fn register(runner: &mut Runner) {
function demo_from_bits_asc_unsigned (line 34) | fn demo_from_bits_asc_unsigned<T: PrimitiveUnsigned>(
function demo_from_bits_asc_signed (line 49) | fn demo_from_bits_asc_signed<T: PrimitiveSigned>(gm: GenMode, config: &G...
function demo_from_bits_desc_unsigned (line 60) | fn demo_from_bits_desc_unsigned<T: PrimitiveUnsigned>(
function demo_from_bits_desc_signed (line 75) | fn demo_from_bits_desc_signed<T: PrimitiveSigned>(gm: GenMode, config: &...
function benchmark_from_bits_asc_algorithms_unsigned (line 86) | fn benchmark_from_bits_asc_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_from_bits_asc_algorithms_signed (line 114) | fn benchmark_from_bits_asc_algorithms_signed<T: PrimitiveSigned>(
function benchmark_from_bits_desc_algorithms_unsigned (line 142) | fn benchmark_from_bits_desc_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_from_bits_desc_algorithms_signed (line 167) | fn benchmark_from_bits_desc_algorithms_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_convertible/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_convertible/to_bits.rs
function register (line 22) | pub(crate) fn register(runner: &mut Runner) {
function demo_to_bits_asc_unsigned (line 38) | fn demo_to_bits_asc_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: ...
function demo_to_bits_asc_signed (line 44) | fn demo_to_bits_asc_signed<T: PrimitiveSigned>(gm: GenMode, config: &Gen...
function demo_to_bits_desc_unsigned (line 50) | fn demo_to_bits_desc_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config:...
function demo_to_bits_desc_signed (line 56) | fn demo_to_bits_desc_signed<T: PrimitiveSigned>(gm: GenMode, config: &Ge...
function benchmark_to_bits_asc_algorithms_unsigned (line 62) | fn benchmark_to_bits_asc_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_to_bits_asc_algorithms_signed (line 84) | fn benchmark_to_bits_asc_algorithms_signed<T: PrimitiveSigned>(
function benchmark_to_bits_asc_evaluation_strategy_unsigned (line 107) | fn benchmark_to_bits_asc_evaluation_strategy_unsigned<T: PrimitiveUnsign...
function benchmark_to_bits_asc_evaluation_strategy_signed (line 133) | fn benchmark_to_bits_asc_evaluation_strategy_signed<T: PrimitiveSigned>(
function benchmark_to_bits_desc_algorithms_unsigned (line 158) | fn benchmark_to_bits_desc_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_to_bits_desc_algorithms_signed (line 180) | fn benchmark_to_bits_desc_algorithms_signed<T: PrimitiveSigned>(
function benchmark_to_bits_desc_evaluation_strategy_unsigned (line 203) | fn benchmark_to_bits_desc_evaluation_strategy_unsigned<T: PrimitiveUnsig...
function benchmark_to_bits_desc_evaluation_strategy_signed (line 230) | fn benchmark_to_bits_desc_evaluation_strategy_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_iterable.rs
function register (line 22) | pub(crate) fn register(runner: &mut Runner) {
function demo_bits_unsigned (line 35) | fn demo_bits_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &GenCon...
function demo_bits_signed (line 41) | fn demo_bits_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenConfig,...
function demo_bits_rev_unsigned (line 47) | fn demo_bits_rev_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &Ge...
function demo_bits_rev_signed (line 53) | fn demo_bits_rev_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenCon...
function demo_bits_size_hint_unsigned (line 59) | fn demo_bits_size_hint_unsigned<T: PrimitiveUnsigned>(
function demo_bits_index_signed (line 69) | fn demo_bits_index_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function benchmark_bits_size_hint_unsigned (line 81) | fn benchmark_bits_size_hint_unsigned<T: PrimitiveUnsigned>(
function benchmark_bits_get_algorithms_unsigned (line 102) | fn benchmark_bits_get_algorithms_unsigned<T: PrimitiveUnsigned>(
function benchmark_bits_get_algorithms_signed (line 136) | fn benchmark_bits_get_algorithms_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_scan/index_of_next_false_bit.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_index_of_next_false_bit_unsigned (line 26) | fn demo_index_of_next_false_bit_unsigned<T: PrimitiveUnsigned>(
function demo_index_of_next_false_bit_signed (line 44) | fn demo_index_of_next_false_bit_signed<T: PrimitiveSigned>(
function benchmark_index_of_next_false_bit_unsigned (line 62) | fn benchmark_index_of_next_false_bit_unsigned<T: PrimitiveUnsigned>(
function benchmark_index_of_next_false_bit_signed (line 82) | fn benchmark_index_of_next_false_bit_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_scan/index_of_next_true_bit.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_index_of_next_true_bit_unsigned (line 26) | fn demo_index_of_next_true_bit_unsigned<T: PrimitiveUnsigned>(
function demo_index_of_next_true_bit_signed (line 44) | fn demo_index_of_next_true_bit_signed<T: PrimitiveSigned>(
function benchmark_index_of_next_true_bit_unsigned (line 62) | fn benchmark_index_of_next_true_bit_unsigned<T: PrimitiveUnsigned>(
function benchmark_index_of_next_true_bit_signed (line 82) | fn benchmark_index_of_next_true_bit_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/bit_scan/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/get_highest_bit.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/hamming_distance.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_hamming_distance_unsigned (line 24) | fn demo_hamming_distance_unsigned<T: PrimitiveUnsigned>(
function demo_checked_hamming_distance_signed (line 34) | fn demo_checked_hamming_distance_signed<T: PrimitiveSigned>(
function benchmark_hamming_distance_unsigned (line 49) | fn benchmark_hamming_distance_unsigned<T: PrimitiveUnsigned>(
function benchmark_checked_hamming_distance_signed (line 67) | fn benchmark_checked_hamming_distance_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/low_mask.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_low_mask (line 21) | fn demo_low_mask<T: PrimitiveInt>(gm: GenMode, config: &GenConfig, limit...
function benchmark_low_mask (line 27) | fn benchmark_low_mask<T: PrimitiveInt>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/not_assign.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_not_assign_unsigned (line 24) | fn demo_not_assign_unsigned<T: PrimitiveUnsigned>(gm: GenMode, config: &...
function demo_not_assign_signed (line 32) | fn demo_not_assign_signed<T: PrimitiveSigned>(gm: GenMode, config: &GenC...
function benchmark_not_assign_unsigned (line 40) | fn benchmark_not_assign_unsigned<T: PrimitiveUnsigned>(
function benchmark_not_assign_signed (line 58) | fn benchmark_not_assign_signed<T: PrimitiveSigned>(
FILE: malachite-base/src/bin_util/demo_and_bench/num/logic/significant_bits.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/num/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/access/get.rs
function register (line 18) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_get (line 26) | fn demo_rational_sequence_get(gm: GenMode, config: &GenConfig, limit: us...
function demo_rational_sequence_index (line 35) | fn demo_rational_sequence_index(gm: GenMode, config: &GenConfig, limit: ...
function benchmark_rational_sequence_get (line 44) | fn benchmark_rational_sequence_get(gm: GenMode, config: &GenConfig, limi...
function benchmark_rational_sequence_index (line 58) | fn benchmark_rational_sequence_index(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/access/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/access/mutate.rs
function register (line 15) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_mutate (line 20) | fn demo_rational_sequence_mutate(gm: GenMode, config: &GenConfig, limit:...
function benchmark_rational_sequence_mutate (line 31) | fn benchmark_rational_sequence_mutate(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/basic/component_len.rs
function register (line 15) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_component_len (line 20) | fn demo_rational_sequence_component_len(gm: GenMode, config: &GenConfig,...
function benchmark_rational_sequence_component_len (line 29) | fn benchmark_rational_sequence_component_len(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/basic/is_empty.rs
function register (line 15) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_is_empty (line 20) | fn demo_rational_sequence_is_empty(gm: GenMode, config: &GenConfig, limi...
function benchmark_rational_sequence_is_empty (line 33) | fn benchmark_rational_sequence_is_empty(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/basic/is_finite.rs
function register (line 15) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_is_finite (line 20) | fn demo_rational_sequence_is_finite(gm: GenMode, config: &GenConfig, lim...
function benchmark_rational_sequence_is_finite (line 33) | fn benchmark_rational_sequence_is_finite(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/basic/iter.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_iter (line 22) | fn demo_rational_sequence_iter(gm: GenMode, config: &GenConfig, limit: u...
function benchmark_rational_sequence_iter (line 31) | fn benchmark_rational_sequence_iter(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/basic/len.rs
function register (line 15) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_len (line 20) | fn demo_rational_sequence_len(gm: GenMode, config: &GenConfig, limit: us...
function benchmark_rational_sequence_len (line 29) | fn benchmark_rational_sequence_len(gm: GenMode, config: &GenConfig, limi...
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/basic/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/comparison/cmp.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_cmp (line 21) | fn demo_rational_sequence_cmp(gm: GenMode, config: &GenConfig, limit: us...
function benchmark_rational_sequence_cmp (line 35) | fn benchmark_rational_sequence_cmp(gm: GenMode, config: &GenConfig, limi...
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/comparison/eq.rs
function register (line 15) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_eq (line 20) | fn demo_rational_sequence_eq(gm: GenMode, config: &GenConfig, limit: usi...
function benchmark_rational_sequence_eq (line 34) | fn benchmark_rational_sequence_eq(gm: GenMode, config: &GenConfig, limit...
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/comparison/hash.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_hash (line 21) | fn demo_rational_sequence_hash(gm: GenMode, config: &GenConfig, limit: u...
function benchmark_rational_sequence_hash (line 30) | fn benchmark_rational_sequence_hash(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/comparison/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/conversion/clone.rs
function register (line 19) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_clone (line 26) | fn demo_rational_sequence_clone(gm: GenMode, config: &GenConfig, limit: ...
function demo_rational_sequence_clone_from (line 35) | fn demo_rational_sequence_clone_from(gm: GenMode, config: &GenConfig, li...
function benchmark_rational_sequence_clone (line 47) | fn benchmark_rational_sequence_clone(
function benchmark_rational_sequence_clone_from (line 65) | fn benchmark_rational_sequence_clone_from(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/conversion/from_vec.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_from_vec (line 26) | fn demo_rational_sequence_from_vec(gm: GenMode, config: &GenConfig, limi...
function demo_rational_sequence_from_slice (line 36) | fn demo_rational_sequence_from_slice(gm: GenMode, config: &GenConfig, li...
function benchmark_rational_sequence_from_vec_evaluation_strategy (line 46) | fn benchmark_rational_sequence_from_vec_evaluation_strategy(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/conversion/from_vecs.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_from_vecs (line 26) | fn demo_rational_sequence_from_vecs(gm: GenMode, config: &GenConfig, lim...
function demo_rational_sequence_from_slices (line 37) | fn demo_rational_sequence_from_slices(gm: GenMode, config: &GenConfig, l...
function benchmark_rational_sequence_from_vecs_evaluation_strategy (line 48) | fn benchmark_rational_sequence_from_vecs_evaluation_strategy(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/conversion/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/conversion/to_vecs.rs
function register (line 15) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_to_vecs (line 26) | fn demo_rational_sequence_to_vecs(gm: GenMode, config: &GenConfig, limit...
function demo_rational_sequence_into_vecs (line 35) | fn demo_rational_sequence_into_vecs(gm: GenMode, config: &GenConfig, lim...
function demo_rational_sequence_slices_ref (line 44) | fn demo_rational_sequence_slices_ref(gm: GenMode, config: &GenConfig, li...
function benchmark_rational_sequence_to_vecs_evaluation_strategy (line 53) | fn benchmark_rational_sequence_to_vecs_evaluation_strategy(
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/rational_sequences/to_string.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_rational_sequence_to_string (line 24) | fn demo_rational_sequence_to_string(gm: GenMode, config: &GenConfig, lim...
function demo_rational_sequence_to_debug_string (line 33) | fn demo_rational_sequence_to_debug_string(gm: GenMode, config: &GenConfi...
function benchmark_rational_sequence_to_string (line 42) | fn benchmark_rational_sequence_to_string(
function benchmark_rational_sequence_to_debug_string (line 60) | fn benchmark_rational_sequence_to_debug_string(
FILE: malachite-base/src/bin_util/demo_and_bench/rounding_modes/clone.rs
function register (line 13) | pub(crate) fn register(runner: &mut Runner) {
function demo_rounding_mode_clone (line 18) | fn demo_rounding_mode_clone(gm: GenMode, config: &GenConfig, limit: usiz...
function demo_rounding_mode_clone_from (line 24) | fn demo_rounding_mode_clone_from(gm: GenMode, config: &GenConfig, limit:...
FILE: malachite-base/src/bin_util/demo_and_bench/rounding_modes/eq.rs
function register (line 13) | pub(crate) fn register(runner: &mut Runner) {
function demo_rounding_mode_eq (line 17) | fn demo_rounding_mode_eq(gm: GenMode, config: &GenConfig, limit: usize) {
FILE: malachite-base/src/bin_util/demo_and_bench/rounding_modes/from_str.rs
function register (line 17) | pub(crate) fn register(runner: &mut Runner) {
function demo_rounding_mode_from_str (line 23) | fn demo_rounding_mode_from_str(gm: GenMode, config: &GenConfig, limit: u...
function demo_rounding_mode_from_str_targeted (line 33) | fn demo_rounding_mode_from_str_targeted(gm: GenMode, config: &GenConfig,...
function benchmark_rounding_mode_from_str (line 44) | fn benchmark_rounding_mode_from_str(
FILE: malachite-base/src/bin_util/demo_and_bench/rounding_modes/hash.rs
function register (line 14) | pub(crate) fn register(runner: &mut Runner) {
function demo_rounding_mode_hash (line 18) | fn demo_rounding_mode_hash(gm: GenMode, config: &GenConfig, limit: usize) {
FILE: malachite-base/src/bin_util/demo_and_bench/rounding_modes/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/rounding_modes/neg.rs
function register (line 14) | pub(crate) fn register(runner: &mut Runner) {
function demo_rounding_mode_neg_assign (line 19) | fn demo_rounding_mode_neg_assign(gm: GenMode, config: &GenConfig, limit:...
function demo_rounding_mode_neg (line 27) | fn demo_rounding_mode_neg(gm: GenMode, config: &GenConfig, limit: usize) {
FILE: malachite-base/src/bin_util/demo_and_bench/rounding_modes/to_string.rs
function register (line 13) | pub(crate) fn register(runner: &mut Runner) {
function demo_rounding_mode_to_string (line 17) | fn demo_rounding_mode_to_string(gm: GenMode, config: &GenConfig, limit: ...
FILE: malachite-base/src/bin_util/demo_and_bench/slices/min_repeating_len.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_min_repeating_len (line 21) | fn demo_min_repeating_len(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_min_repeating_len (line 27) | fn benchmark_min_repeating_len(gm: GenMode, config: &GenConfig, limit: u...
FILE: malachite-base/src/bin_util/demo_and_bench/slices/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/slices/slice_leading_zeros.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_slice_leading_zeros (line 21) | fn demo_slice_leading_zeros(gm: GenMode, config: &GenConfig, limit: usiz...
function benchmark_slice_leading_zeros (line 31) | fn benchmark_slice_leading_zeros(gm: GenMode, config: &GenConfig, limit:...
FILE: malachite-base/src/bin_util/demo_and_bench/slices/slice_move_left.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_slice_move_left (line 21) | fn demo_slice_move_left(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_slice_move_left (line 32) | fn benchmark_slice_move_left(gm: GenMode, config: &GenConfig, limit: usi...
FILE: malachite-base/src/bin_util/demo_and_bench/slices/slice_set_zero.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_slice_set_zero (line 21) | fn demo_slice_set_zero(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_slice_set_zero (line 29) | fn benchmark_slice_set_zero(gm: GenMode, config: &GenConfig, limit: usiz...
FILE: malachite-base/src/bin_util/demo_and_bench/slices/slice_test_zero.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_slice_test_zero (line 21) | fn demo_slice_test_zero(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_slice_test_zero (line 27) | fn benchmark_slice_test_zero(gm: GenMode, config: &GenConfig, limit: usi...
FILE: malachite-base/src/bin_util/demo_and_bench/slices/slice_trailing_zeros.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_slice_trailing_zeros (line 21) | fn demo_slice_trailing_zeros(gm: GenMode, config: &GenConfig, limit: usi...
function benchmark_slice_trailing_zeros (line 31) | fn benchmark_slice_trailing_zeros(gm: GenMode, config: &GenConfig, limit...
FILE: malachite-base/src/bin_util/demo_and_bench/slices/split_into_chunks.rs
function register (line 15) | pub(crate) fn register(runner: &mut Runner) {
function demo_split_into_chunks (line 39) | fn demo_split_into_chunks(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_split_into_chunks_mut (line 83) | fn demo_split_into_chunks_mut(gm: GenMode, config: &GenConfig, limit: us...
FILE: malachite-base/src/bin_util/demo_and_bench/strings/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/strings/string_is_subset.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_string_is_subset (line 22) | fn demo_string_is_subset(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_string_is_subset_ascii (line 33) | fn demo_string_is_subset_ascii(gm: GenMode, config: &GenConfig, limit: u...
function benchmark_string_is_subset (line 44) | fn benchmark_string_is_subset(gm: GenMode, config: &GenConfig, limit: us...
FILE: malachite-base/src/bin_util/demo_and_bench/strings/string_sort.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_string_sort (line 22) | fn demo_string_sort(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_string_sort_ascii (line 28) | fn demo_string_sort_ascii(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_string_sort (line 34) | fn benchmark_string_sort(gm: GenMode, config: &GenConfig, limit: usize, ...
FILE: malachite-base/src/bin_util/demo_and_bench/strings/string_unique.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_string_unique (line 23) | fn demo_string_unique(gm: GenMode, config: &GenConfig, limit: usize) {
function demo_string_unique_ascii (line 29) | fn demo_string_unique_ascii(gm: GenMode, config: &GenConfig, limit: usiz...
function benchmark_string_unique (line 35) | fn benchmark_string_unique(gm: GenMode, config: &GenConfig, limit: usize...
FILE: malachite-base/src/bin_util/demo_and_bench/vecs/mod.rs
function register (line 11) | pub(crate) fn register(runner: &mut Runner) {
FILE: malachite-base/src/bin_util/demo_and_bench/vecs/vec_delete_left.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_vec_delete_left (line 21) | fn demo_vec_delete_left(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_vec_delete_left (line 32) | fn benchmark_vec_delete_left(gm: GenMode, config: &GenConfig, limit: usi...
FILE: malachite-base/src/bin_util/demo_and_bench/vecs/vec_pad_left.rs
function register (line 16) | pub(crate) fn register(runner: &mut Runner) {
function demo_vec_pad_left (line 21) | fn demo_vec_pad_left(gm: GenMode, config: &GenConfig, limit: usize) {
function benchmark_vec_pad_left (line 33) | fn benchmark_vec_pad_left(gm: GenMode, config: &GenConfig, limit: usize,...
FILE: malachite-base/src/bin_util/generate/max_base.rs
function max_base_helper (line 11) | fn max_base_helper<T: PrimitiveUnsigned>() {
function generate_max_base (line 39) | pub(crate) fn generate_max_base() {
FILE: malachite-base/src/bin_util/generate/rle.rs
function generate_rle_encoding (line 11) | pub(crate) fn generate_rle_encoding() {
FILE: malachite-base/src/bin_util/generate/tuning_manager.rs
constant PARENT_PATHS (line 15) | const PARENT_PATHS: [&str; 2] = ["../malachite-base/src", "../malachite-...
function find_all_file_paths (line 17) | fn find_all_file_paths() -> BTreeSet<String> {
function primitive_tokenize (line 31) | fn primitive_tokenize(s: &str) -> Vec<String> {
constant FN_PREFIXES (line 49) | const FN_PREFIXES: [&str; 6] =
constant ALLOWED_DOUBLE_NAMES (line 52) | const ALLOWED_DOUBLE_NAMES: [&str; 3] = ["limbs_mod_limb", "oz_fmt", "fa...
type FunctionRecord (line 55) | struct FunctionRecord {
function get_all_top_level_functions (line 61) | fn get_all_top_level_functions() -> BTreeMap<String, FunctionRecord> {
constant CONST_PREFIXES (line 93) | const CONST_PREFIXES: [&str; 3] = ["pub const ", "pub(crate) const ", "c...
function get_all_tuneable_constants (line 95) | fn get_all_tuneable_constants() -> BTreeMap<String, FunctionRecord> {
function extract_functions_and_constants (line 143) | fn extract_functions_and_constants(
function get_referenced_items_for_constant (line 174) | fn get_referenced_items_for_constant(
function get_referenced_items_for_function (line 213) | fn get_referenced_items_for_function(
type ReferenceData (line 250) | pub struct ReferenceData {
function parse_and_get_references (line 259) | fn parse_and_get_references() -> ReferenceData {
function invert_map (line 286) | fn invert_map(m: &BTreeMap<String, BTreeSet<String>>) -> BTreeMap<String...
function build_reference_data (line 299) | pub fn build_reference_data() {
function hfdm_helper (line 303) | fn hfdm_helper(map: &mut BTreeMap<String, String>, k: &str, v: &str) {
function hardcoded_defining_function_map (line 307) | fn hardcoded_defining_function_map() -> BTreeMap<String, String> {
function generate_defining_function_map (line 322) | fn generate_defining_function_map(data: &ReferenceData) -> BTreeMap<Stri...
function test (line 342) | pub fn test() {
FILE: malachite-base/src/bools/constants.rs
constant MIN (line 14) | const MIN: Self = false;
constant MAX (line 19) | const MAX: Self = true;
FILE: malachite-base/src/bools/exhaustive.rs
type ExhaustiveBools (line 15) | pub type ExhaustiveBools = Copied<Iter<'static, bool>>;
function exhaustive_bools (line 32) | pub fn exhaustive_bools() -> ExhaustiveBools {
FILE: malachite-base/src/bools/not_assign.rs
method not_assign (line 32) | fn not_assign(&mut self) {
FILE: malachite-base/src/bools/random.rs
type RandomBools (line 22) | pub struct RandomBools {
type Item (line 29) | type Item = bool;
method next (line 32) | fn next(&mut self) -> Option<bool> {
function random_bools (line 69) | pub fn random_bools(seed: Seed) -> RandomBools {
type WeightedRandomBools (line 81) | pub struct WeightedRandomBools {
type Item (line 87) | type Item = bool;
method next (line 90) | fn next(&mut self) -> Option<bool> {
function weighted_random_bools (line 126) | pub fn weighted_random_bools(
function get_weighted_random_bool (line 168) | pub fn get_weighted_random_bool(
FILE: malachite-base/src/chars/constants.rs
constant NUMBER_OF_CHARS (line 14) | pub const NUMBER_OF_CHARS: u32 = (1 << 20) + (1 << 16) - NUMBER_OF_SURRO...
constant NUMBER_OF_SURROGATE_CODE_POINTS (line 20) | pub const NUMBER_OF_SURROGATE_CODE_POINTS: u32 = 1 << 11;
constant FIRST_SURROGATE_CODE_POINT (line 23) | pub const FIRST_SURROGATE_CODE_POINT: u32 = 0xd800;
constant CHAR_JUST_BELOW_SURROGATES (line 29) | pub const CHAR_JUST_BELOW_SURROGATES: char = '\u{d7ff}';
constant CHAR_JUST_ABOVE_SURROGATES (line 34) | pub const CHAR_JUST_ABOVE_SURROGATES: char = '\u{e000}';
constant MIN (line 41) | const MIN: Self = '\u{0}';
constant MAX (line 49) | const MAX: Self = core::char::MAX;
FILE: malachite-base/src/chars/crement.rs
function char_to_contiguous_range (line 36) | pub const fn char_to_contiguous_range(c: char) -> u32 {
function contiguous_range_to_char (line 62) | pub const fn contiguous_range_to_char(u: u32) -> Option<char> {
function increment_char (line 93) | pub const fn increment_char(c: &mut char) {
function decrement_char (line 120) | pub fn decrement_char(c: &mut char) {
FILE: malachite-base/src/chars/exhaustive.rs
function ascii_chars_increasing (line 34) | pub const fn ascii_chars_increasing() -> RangeInclusive<char> {
function chars_increasing (line 61) | pub const fn chars_increasing() -> RangeInclusive<char> {
type ExhaustiveChars (line 80) | pub struct ExhaustiveChars {
type Item (line 88) | type Item = char;
method next (line 90) | fn next(&mut self) -> Option<char> {
function exhaustive_ascii_chars (line 195) | pub const fn exhaustive_ascii_chars() -> ExhaustiveChars {
function exhaustive_chars (line 236) | pub const fn exhaustive_chars() -> ExhaustiveChars {
FILE: malachite-base/src/chars/mod.rs
type CharType (line 13) | pub enum CharType {
type CharType (line 24) | enum CharType {
function debug_starts_with_slash (line 33) | fn debug_starts_with_slash(c: char) -> bool {
function char_is_graphic (line 63) | pub fn char_is_graphic(c: char) -> bool {
FILE: malachite-base/src/chars/random.rs
type RandomCharRange (line 21) | pub struct RandomCharRange {
type Item (line 26) | type Item = char;
method next (line 29) | fn next(&mut self) -> Option<char> {
type WeightedGraphicRandomCharRange (line 40) | pub struct WeightedGraphicRandomCharRange {
type Item (line 47) | type Item = char;
method next (line 49) | fn next(&mut self) -> Option<char> {
function random_chars (line 81) | pub fn random_chars(seed: Seed) -> RandomCharRange {
function random_ascii_chars (line 113) | pub fn random_ascii_chars(seed: Seed) -> RandomCharRange {
function random_char_range (line 153) | pub fn random_char_range(seed: Seed, a: char, mut b: char) -> RandomChar...
function random_char_inclusive_range (line 195) | pub fn random_char_inclusive_range(seed: Seed, a: char, b: char) -> Rand...
function graphic_weighted_random_chars (line 247) | pub fn graphic_weighted_random_chars(
function graphic_weighted_random_ascii_chars (line 305) | pub fn graphic_weighted_random_ascii_chars(
function graphic_weighted_random_char_range (line 369) | pub fn graphic_weighted_random_char_range(
function graphic_weighted_random_char_inclusive_range (line 430) | pub fn graphic_weighted_random_char_inclusive_range(
FILE: malachite-base/src/comparison/traits.rs
type Min (line 11) | pub trait Min {
constant MIN (line 13) | const MIN: Self;
type Max (line 18) | pub trait Max {
constant MAX (line 20) | const MAX: Self;
FILE: malachite-base/src/iterators/bit_distributor.rs
constant COUNTER_WIDTH (line 14) | const COUNTER_WIDTH: usize = u64::WIDTH as usize;
type BitDistributorOutputType (line 20) | pub struct BitDistributorOutputType {
method normal (line 36) | pub const fn normal(weight: usize) -> Self {
method tiny (line 51) | pub const fn tiny() -> Self {
type BitDistributor (line 98) | pub struct BitDistributor {
method new_without_init (line 108) | fn new_without_init(output_types: &[BitDistributorOutputType]) -> Self {
method new (line 142) | pub fn new(output_types: &[BitDistributorOutputType]) -> Self {
method bit_map_as_slice (line 177) | pub fn bit_map_as_slice(&self) -> &[usize] {
method update_bit_map (line 181) | fn update_bit_map(&mut self) {
method set_max_bits (line 281) | pub fn set_max_bits(&mut self, output_type_indices: &[usize], max_bits...
method increment_counter (line 313) | pub fn increment_counter(&mut self) {
method get_output (line 357) | pub fn get_output(&self, index: usize) -> usize {
FILE: malachite-base/src/iterators/comparison.rs
type DeltaDirections (line 15) | pub struct DeltaDirections<I: Iterator>
type Item (line 27) | type Item = Ordering;
method next (line 29) | fn next(&mut self) -> Option<Ordering> {
function delta_directions (line 68) | pub const fn delta_directions<I: Iterator>(xs: I) -> DeltaDirections<I>
function is_strictly_ascending (line 92) | pub fn is_strictly_ascending<I: Iterator>(xs: I) -> bool
function is_strictly_descending (line 116) | pub fn is_strictly_descending<I: Iterator>(xs: I) -> bool
function is_weakly_ascending (line 141) | pub fn is_weakly_ascending<I: Iterator>(xs: I) -> bool
function is_weakly_descending (line 166) | pub fn is_weakly_descending<I: Iterator>(xs: I) -> bool
function is_strictly_zigzagging (line 190) | pub fn is_strictly_zigzagging<I: Iterator>(xs: I) -> bool
function is_weakly_zigzagging (line 226) | pub fn is_weakly_zigzagging<I: Iterator>(xs: I) -> bool
FILE: malachite-base/src/iterators/iterator_cache.rs
type IteratorCache (line 17) | pub struct IteratorCache<I: Iterator> {
function new (line 37) | pub const fn new(xs: I) -> Self {
function get (line 73) | pub fn get(&mut self, index: usize) -> Option<&I::Item> {
function assert_get (line 109) | pub fn assert_get(&self, index: usize) -> &I::Item {
function known_len (line 134) | pub const fn known_len(&self) -> Option<usize> {
FILE: malachite-base/src/iterators/mod.rs
type NonzeroValues (line 29) | pub struct NonzeroValues<I: Iterator>(I)
type Item (line 37) | type Item = I::Item;
method next (line 40) | fn next(&mut self) -> Option<I::Item> {
method next_back (line 55) | fn next_back(&mut self) -> Option<I::Item> {
function nonzero_values (line 85) | pub const fn nonzero_values<I: Iterator>(xs: I) -> NonzeroValues<I>
function is_constant (line 108) | pub fn is_constant<I: Iterator>(xs: I) -> bool
function count_is_at_least (line 140) | pub fn count_is_at_least<I: Iterator>(xs: I, n: usize) -> bool {
function count_is_at_most (line 159) | pub fn count_is_at_most<I: Iterator>(xs: I, n: usize) -> bool {
function is_unique (line 181) | pub fn is_unique<I: Iterator>(xs: I) -> bool
function first_and_last (line 210) | pub fn first_and_last<I: Iterator>(xs: &mut I) -> Option<(I::Item, I::It...
function matching_intervals_in_iterator (line 244) | pub fn matching_intervals_in_iterator<I: Iterator, F: Fn(&I::Item) -> bo...
type WithSpecialValue (line 262) | pub struct WithSpecialValue<I: Iterator>
type Item (line 276) | type Item = I::Item;
method next (line 278) | fn next(&mut self) -> Option<I::Item> {
function with_special_value (line 315) | pub fn with_special_value<I: Iterator>(
type WithSpecialValues (line 338) | pub struct WithSpecialValues<I: Iterator>
type Item (line 352) | type Item = I::Item;
method next (line 354) | fn next(&mut self) -> Option<I::Item> {
function with_special_values (line 402) | pub fn with_special_values<I: Iterator>(
type IterWindows (line 423) | pub struct IterWindows<I: Iterator>
type Item (line 436) | type Item = VecDeque<I::Item>;
method next (line 438) | fn next(&mut self) -> Option<VecDeque<I::Item>> {
function iter_windows (line 477) | pub fn iter_windows<I: Iterator>(window_size: usize, xs: I) -> IterWindo...
function prefix_to_string (line 507) | pub fn prefix_to_string<I: Iterator>(mut xs: I, max_len: usize) -> String
type ThueMorseSequence (line 539) | pub struct ThueMorseSequence(u64);
type Item (line 542) | type Item = bool;
method next (line 544) | fn next(&mut self) -> Option<bool> {
function thue_morse_sequence (line 573) | pub const fn thue_morse_sequence() -> ThueMorseSequence {
FILE: malachite-base/src/lib.rs
function fail_on_untested_path (line 138) | pub fn fail_on_untested_path(message: &str) {
function fail_on_untested_path (line 145) | pub const fn fail_on_untested_path(_message: &str) {}
FILE: malachite-base/src/named/mod.rs
type Named (line 11) | pub trait Named {
constant NAME (line 13) | const NAME: &'static str;
FILE: malachite-base/src/nevers/mod.rs
type Never (line 24) | pub enum Never {}
method fmt (line 28) | fn fmt(&self, _f: &mut Formatter) -> core::fmt::Result {
type NeverError (line 34) | pub struct NeverError;
type Err (line 37) | type Err = NeverError;
method from_str (line 54) | fn from_str(_: &str) -> Result<Self, NeverError> {
function nevers (line 73) | pub const fn nevers() -> Empty<Never> {
FILE: malachite-base/src/num/arithmetic/arithmetic_checked_shl.rs
function arithmetic_checked_shl_unsigned_unsigned (line 15) | fn arithmetic_checked_shl_unsigned_unsigned<
function arithmetic_checked_shl_unsigned_signed (line 73) | fn arithmetic_checked_shl_unsigned_signed<
function arithmetic_checked_shl_signed_unsigned (line 136) | fn arithmetic_checked_shl_signed_unsigned<
function arithmetic_checked_shl_signed_signed (line 199) | fn arithmetic_checked_shl_signed_signed<
FILE: malachite-base/src/num/arithmetic/arithmetic_checked_shr.rs
function arithmetic_checked_shr_unsigned_signed (line 14) | fn arithmetic_checked_shr_unsigned_signed<
function arithmetic_checked_shr_signed_signed (line 76) | fn arithmetic_checked_shr_signed_signed<
FILE: malachite-base/src/num/arithmetic/binomial_coefficient.rs
function checked_binomial_coefficient_unsigned (line 18) | fn checked_binomial_coefficient_unsigned<T: PrimitiveUnsigned>(n: T, mut...
function checked_binomial_coefficient_sign
Copy disabled (too large)
Download .json
Condensed preview — 2707 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (38,889K chars).
[
{
"path": ".envrc",
"chars": 234,
"preview": "if ! has nix_direnv_version || ! nix_direnv_version 2.3.0; then\n source_url \"https://raw.githubusercontent.com/nix-co"
},
{
"path": ".github/FUNDING.yml",
"chars": 18,
"preview": "github: mhogrefe\n\n"
},
{
"path": ".github/workflows/rust.yml",
"chars": 330,
"preview": "name: Rust\n\non:\n push:\n branches: [ \"master\" ]\n pull_request:\n branches: [ \"master\" ]\n\nenv:\n CARGO_TERM_COLOR: "
},
{
"path": ".gitignore",
"chars": 102,
"preview": "target\n*.bk\n.idea*\n*.iml\nsrc/integer_old.rs\n*.DS_Store\n*/.vscode/*\n*.history/*\n*/.history/*\n\n.direnv/\n"
},
{
"path": ".vscode/launch.json",
"chars": 432,
"preview": "{\n \"version\": \"0.2.0\",\n \"configurations\": [\n {\n \"name\": \"malachite-nz-test-util\",\n \"t"
},
{
"path": ".vscode/tasks.json",
"chars": 4930,
"preview": "{\n // See https://go.microsoft.com/fwlink/?LinkId=733558\n // for the documentation about the tasks.json format\n "
},
{
"path": "COPYING",
"chars": 35149,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free "
},
{
"path": "COPYING.LESSER",
"chars": 7651,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007"
},
{
"path": "Cargo.toml",
"chars": 670,
"preview": "[workspace]\nmembers = ['malachite', 'malachite-base', 'malachite-bigint', 'malachite-float', 'malachite-nz', 'malachite-"
},
{
"path": "LICENSE",
"chars": 7651,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007"
},
{
"path": "README.md",
"chars": 1232,
"preview": "<img width=\"500\" src=\"docs/assets/logo-and-name.svg\" alt=\"Logo\">\n\nAn arbitrary-precision arithmetic library for Rust.\n\nP"
},
{
"path": "_config.yml",
"chars": 26,
"preview": "theme: jekyll-theme-cayman"
},
{
"path": "additional-lints.py",
"chars": 4367,
"preview": "import os\n\nMAX_LINE_LENGTH = 100\n\nline_length_exceptions = set((\n # long Markdown table rows and/or links\n ('./mal"
},
{
"path": "build.sh",
"chars": 22846,
"preview": "#!/bin/bash\necho \"Step 1. Checking for updates\" &&\nrustup update &&\necho \"Step 2. Updating headers\" &&\ncd ../fix-headers"
},
{
"path": "docs/CNAME",
"chars": 16,
"preview": "www.malachite.rs"
},
{
"path": "docs/_config.yml",
"chars": 25,
"preview": "theme: jekyll-theme-slate"
},
{
"path": "docs/_includes/head-custom.html",
"chars": 758,
"preview": "<link rel=\"shortcut icon\" type=\"image/x-icon\" href=\"{{ \"/assets/favicon.ico\" | absolute_url }}\">\n<link rel=\"stylesheet\""
},
{
"path": "docs/_layouts/post.html",
"chars": 198,
"preview": "---\nlayout: default\ntheme: jekyll-theme-slate\n---\n<h1>{{ page.title }}</h1>\n<p><b>{{ page.date | date_to_string }}</b> —"
},
{
"path": "docs/_posts/2022-06-05-1-intro.md",
"chars": 436,
"preview": "---\nlayout: post\ntitle: Intro\nauthor: Mikhail Hogrefe\n---\n\nWelcome to the Malachite blog!\n\nAfter 5 years and over 600,00"
},
{
"path": "docs/_posts/2022-06-05-2-exhaustive.md",
"chars": 5347,
"preview": "---\nlayout: post\ntitle: Iterators that generate everything, part 1\nauthor: Mikhail Hogrefe\n---\n\n## Iterators\n\nIf you've "
},
{
"path": "docs/_posts/2022-07-03-exhaustive.md",
"chars": 12171,
"preview": "---\nlayout: post\ntitle: Iterators that generate everything, part 2\nauthor: Mikhail Hogrefe\n---\n\n## Introduction\n\nIn [Par"
},
{
"path": "docs/_posts/2022-07-30-denominators.md",
"chars": 10455,
"preview": "---\nlayout: post\ntitle: Which denominators does an interval contain?\nauthor: Mikhail Hogrefe\n---\n\n## Introduction\n\nIn th"
},
{
"path": "docs/assets/denominators/gap-and-bound-graph.asy",
"chars": 894,
"preview": "import graph;\n\nsize(600,400,IgnoreAspect);\n\nint gcd(int a, int b) {\n while (b != 0) {\n int t = b;\n b = a % b;\n "
},
{
"path": "docs/assets/denominators/gap-graph.asy",
"chars": 681,
"preview": "import graph;\n\nsize(600,400,IgnoreAspect);\n\nint gcd(int a, int b) {\n while (b != 0) {\n int t = b;\n b = a % b;\n "
},
{
"path": "docs/assets/denominators/gaps.asy",
"chars": 1655,
"preview": "import graph;\nsize(15cm);\npen small=fontcommand(\"\\scriptsize\");\n\nint gcd(int a, int b) {\n while (b != 0) {\n int t = "
},
{
"path": "docs/assets/denominators/j-graph.asy",
"chars": 681,
"preview": "import graph;\n\nsize(600,400,IgnoreAspect);\n\nint gcd(int a, int b) {\n while (b != 0) {\n int t = b;\n b = a % b;\n "
},
{
"path": "docs/assets/denominators/sixths.asy",
"chars": 930,
"preview": "import graph;\nsize(10cm);\nguide gaxis=(0,0)--(20,0);\npen small=fontcommand(\"\\footnotesize\");\ndraw(gaxis);\n\nfor(int i = 0"
},
{
"path": "docs/assets/exhaustive-part-2/cantor-graph.asy",
"chars": 546,
"preview": "import graph;\n\nsize(600,400,IgnoreAspect);\n\npair unpair(int i) {\n int j = 0;\n int r = i;\n while (r >= j) {\n r -= j"
},
{
"path": "docs/assets/exhaustive-part-2/cantor-grid.asy",
"chars": 701,
"preview": "unitsize(1cm);\nint size = 5;\nfor (int x = 0; x < size; ++x) {\n for (int y = 0; y < size; ++y) {\n dot((x, y));\n }\n}\n"
},
{
"path": "docs/assets/exhaustive-part-2/cantor-large.tex",
"chars": 438,
"preview": "\\documentclass[11pt]{article}\n\\usepackage{amsmath}\n\n\\begin{document}\n\n\\begin{equation*}\n\\begin{split}\n3^{20} &\\rightarr"
},
{
"path": "docs/assets/exhaustive-part-2/cantor-triples-large.tex",
"chars": 448,
"preview": "\\documentclass[11pt]{article}\n\\usepackage{amsmath}\n\n\\begin{document}\n\n\\begin{equation*}\n\\begin{split}\n3^{20} &\\rightarr"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-bits-1.tex",
"chars": 417,
"preview": "\\documentclass[11pt]{article}\n\\usepackage{amsmath}\n\n\\begin{document}\n\n\\begin{tabular}{rcr}\n0 & $\\rightarrow$ & \\ldots 00"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-bits-2.tex",
"chars": 1929,
"preview": "\\documentclass[11pt]{article}\n\\usepackage{amsmath}\n\\usepackage{xcolor}\n\n\\begin{document}\n\n\\begin{tabular}{rcrcrcr}\n0 & $"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-grid-filtered.asy",
"chars": 1009,
"preview": "unitsize(1cm);\nint size = 8;\nfor (int x = 0; x < size; ++x) {\n for (int y = 0; y < size; ++y) {\n if (y < 2) {\n \td"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-grid.asy",
"chars": 939,
"preview": "unitsize(1cm);\nint size = 8;\nfor (int x = 0; x < size; ++x) {\n for (int y = 0; y < size; ++y) {\n dot((x, y));\n }\n}\n"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-large.tex",
"chars": 436,
"preview": "\\documentclass[11pt]{article}\n\\usepackage{amsmath}\n\n\\begin{document}\n\n\\begin{equation*}\n\\begin{split}\n3^{20} &\\rightarr"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-pairs-graph.asy",
"chars": 774,
"preview": "import graph;\n\nsize(600,400,IgnoreAspect);\n\npair unpair(int i) {\n int x = 0;\n int y = 0;\n bool on_x = false;\n int ou"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-triples-bits.tex",
"chars": 4519,
"preview": "\\documentclass[11pt]{article}\n\\usepackage{amsmath}\n\\usepackage{xcolor}\n\n\\begin{document}\n\n\\begin{tabular}{rcrcrcr}\n0 & $"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-triples-graph.asy",
"chars": 955,
"preview": "import graph;\n\nsize(600,400,IgnoreAspect);\n\ntriple untriple(int i) {\n int x = 0;\n int y = 0;\n int z = 0;\n int j = 2;"
},
{
"path": "docs/assets/exhaustive-part-2/interleave-triples-large.tex",
"chars": 448,
"preview": "\\documentclass[11pt]{article}\n\\usepackage{amsmath}\n\n\\begin{document}\n\n\\begin{equation*}\n\\begin{split}\n3^{20} &\\rightarr"
},
{
"path": "docs/assets/logo.asy",
"chars": 1994,
"preview": "unitsize(1mm);\n\npair p1 = (25.0, -279.5970461708813);\npair p2 = (73.21397343575165, -453.91200545461675);\npair p3 = (87."
},
{
"path": "docs/index.md",
"chars": 8426,
"preview": "<p align=\"center\">\r\n <img width=\"650\" src=\"/assets/logo-and-name.svg\" alt=\"Logo\">\r\n</p>\r\n\r\nMalachite is an arbitrary-pr"
},
{
"path": "docs/performance.md",
"chars": 4939,
"preview": "---\nlayout: default\ntitle: \"Malachite Performance\"\npermalink: /performance/\ntheme: jekyll-theme-slate\n---\n\n# Performance"
},
{
"path": "find_replace.py",
"chars": 1227,
"preview": "import os\nimport sys\n\ndef search_replace(filename, old, new):\n with open(filename) as f:\n new_lines = []\n "
},
{
"path": "flake.nix",
"chars": 1815,
"preview": "{\n description = \"malachite development environment\";\n inputs = {\n nixpkgs.url = \"github:NixOS/nixpkgs/nixpkgs-unst"
},
{
"path": "katex-header.html",
"chars": 1040,
"preview": "<link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.css\" integrity=\"sha384-9eLZqc9ds8e"
},
{
"path": "malachite/Cargo.toml",
"chars": 2003,
"preview": "[package]\nname = \"malachite\"\nversion = \"0.9.1\"\nauthors = [\"Mikhail Hogrefe <mikhailhogrefe@gmail.com>\"]\nrust-version.wor"
},
{
"path": "malachite/katex-header.html",
"chars": 1040,
"preview": "<link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.css\" integrity=\"sha384-9eLZqc9ds8e"
},
{
"path": "malachite/src/lib.rs",
"chars": 1844,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/.gitignore",
"chars": 25,
"preview": "target\n*.bk\n.idea*\n*.iml\n"
},
{
"path": "malachite-base/Cargo.toml",
"chars": 1908,
"preview": "[package]\nname = \"malachite-base\"\nversion = \"0.9.1\"\nauthors = [\"Mikhail Hogrefe <mikhailhogrefe@gmail.com>\"]\nrust-versio"
},
{
"path": "malachite-base/README.md",
"chars": 5519,
"preview": "- [crates.io](https://crates.io/crates/malachite-base)\n- [docs.rs](https://docs.rs/malachite-base/latest/malachite_base/"
},
{
"path": "malachite-base/katex-header.html",
"chars": 1040,
"preview": "<link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.css\" integrity=\"sha384-9eLZqc9ds8e"
},
{
"path": "malachite-base/rustfmt.toml",
"chars": 34,
"preview": "max_width = 100\narray_width = 100\n"
},
{
"path": "malachite-base/src/bin.rs",
"chars": 3707,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/bools/mod.rs",
"chars": 522,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/bools/not_assign.rs",
"chars": 944,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/chars/crement/char_to_contiguous_range.rs",
"chars": 1614,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/chars/crement/contiguous_range_to_char.rs",
"chars": 1647,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/chars/crement/crement.rs",
"chars": 2333,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/chars/crement/mod.rs",
"chars": 719,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/chars/mod.rs",
"chars": 516,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/comparison/macros.rs",
"chars": 4943,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/comparison/mod.rs",
"chars": 514,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/mod.rs",
"chars": 2870,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/abs.rs",
"chars": 2792,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/abs_diff.rs",
"chars": 1732,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/add_mul.rs",
"chars": 7064,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/arithmetic_checked_shl.rs",
"chars": 6336,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/arithmetic_checked_shr.rs",
"chars": 3638,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/binomial_coefficient.rs",
"chars": 5745,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/ceiling.rs",
"chars": 1801,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/checked_add_mul.rs",
"chars": 3004,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/checked_square.rs",
"chars": 2581,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/checked_sub_mul.rs",
"chars": 3004,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/coprime_with.rs",
"chars": 2503,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/div_exact.rs",
"chars": 4514,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/div_mod.rs",
"chars": 13525,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/div_round.rs",
"chars": 5196,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/divisible_by.rs",
"chars": 2809,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/divisible_by_power_of_2.rs",
"chars": 3148,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/eq_mod.rs",
"chars": 2841,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/eq_mod_power_of_2.rs",
"chars": 3205,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/extended_gcd.rs",
"chars": 3469,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/factorial.rs",
"chars": 9133,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/floor.rs",
"chars": 1785,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/gcd.rs",
"chars": 2878,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/is_power_of_2.rs",
"chars": 1788,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/kronecker_symbol.rs",
"chars": 8609,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/lcm.rs",
"chars": 3341,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/log_base.rs",
"chars": 4095,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/log_base_2.rs",
"chars": 6778,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/log_base_power_of_2.rs",
"chars": 8364,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod.rs",
"chars": 6210,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_add.rs",
"chars": 2628,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_inverse.rs",
"chars": 2395,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_is_reduced.rs",
"chars": 1789,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_mul.rs",
"chars": 9223,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_neg.rs",
"chars": 2506,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_op.rs",
"chars": 8687,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_pow.rs",
"chars": 4843,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2.rs",
"chars": 13830,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_add.rs",
"chars": 2933,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_inverse.rs",
"chars": 2551,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_is_reduced.rs",
"chars": 1906,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_mul.rs",
"chars": 2933,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_neg.rs",
"chars": 2741,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_pow.rs",
"chars": 2968,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_shl.rs",
"chars": 6233,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_shr.rs",
"chars": 3460,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_square.rs",
"chars": 2852,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_power_of_2_sub.rs",
"chars": 2933,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_shl.rs",
"chars": 5996,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_shr.rs",
"chars": 3528,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_square.rs",
"chars": 3460,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/mod_sub.rs",
"chars": 2628,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/neg.rs",
"chars": 2793,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/next_power_of_2.rs",
"chars": 4107,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_abs.rs",
"chars": 1758,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_add.rs",
"chars": 4892,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_add_mul.rs",
"chars": 5499,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_div.rs",
"chars": 4978,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_mul.rs",
"chars": 4892,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_neg.rs",
"chars": 2930,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_pow.rs",
"chars": 3060,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_square.rs",
"chars": 4737,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_sub.rs",
"chars": 4892,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/overflowing_sub_mul.rs",
"chars": 5499,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/parity.rs",
"chars": 4195,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/pow.rs",
"chars": 5167,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/power_of_2.rs",
"chars": 4565,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/primorial.rs",
"chars": 4803,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/reciprocal.rs",
"chars": 2855,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/root.rs",
"chars": 35249,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/rotate.rs",
"chars": 4835,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/round_to_multiple.rs",
"chars": 6273,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/round_to_multiple_of_power_of_2.rs",
"chars": 6325,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_abs.rs",
"chars": 1688,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_add.rs",
"chars": 4674,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_add_mul.rs",
"chars": 5389,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_mul.rs",
"chars": 4674,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_neg.rs",
"chars": 1688,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_pow.rs",
"chars": 2920,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_square.rs",
"chars": 4577,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_sub.rs",
"chars": 4674,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/saturating_sub_mul.rs",
"chars": 5389,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/shl_round.rs",
"chars": 6152,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/shr_round.rs",
"chars": 11318,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/sign.rs",
"chars": 3390,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/sqrt.rs",
"chars": 13910,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/square.rs",
"chars": 6724,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/sub_mul.rs",
"chars": 7064,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_abs.rs",
"chars": 1672,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_add.rs",
"chars": 4595,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_add_mul.rs",
"chars": 5310,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_div.rs",
"chars": 4681,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_mul.rs",
"chars": 4595,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_neg.rs",
"chars": 2758,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_pow.rs",
"chars": 2888,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_square.rs",
"chars": 4498,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_sub.rs",
"chars": 4595,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/wrapping_sub_mul.rs",
"chars": 5310,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/x_mul_y_to_zz.rs",
"chars": 1920,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xx_add_yy_to_zz.rs",
"chars": 2338,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xx_div_mod_y_to_qr.rs",
"chars": 2265,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xx_sub_yy_to_zz.rs",
"chars": 2338,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xxx_add_yyy_to_zzz.rs",
"chars": 2218,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xxx_sub_yyy_to_zzz.rs",
"chars": 2218,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/arithmetic/xxxx_add_yyyy_to_zzzz.rs",
"chars": 2517,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/comparison/cmp_abs.rs",
"chars": 4277,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/comparison/eq_abs.rs",
"chars": 3279,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/comparison/mod.rs",
"chars": 626,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/comparison/ord_abs_comparators.rs",
"chars": 4041,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/general_digits/from_digits.rs",
"chars": 4881,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/general_digits/mod.rs",
"chars": 572,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/general_digits/to_digits.rs",
"chars": 3175,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/mod.rs",
"chars": 594,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/power_of_2_digits/from_power_of_2_digits.rs",
"chars": 5082,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/power_of_2_digits/mod.rs",
"chars": 696,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/power_of_2_digits/power_of_2_digit_iterable.rs",
"chars": 5743,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/digits/power_of_2_digits/to_power_of_2_digits.rs",
"chars": 4508,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/from/convertible_from.rs",
"chars": 7174,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/from/mod.rs",
"chars": 844,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/from/overflowing_from.rs",
"chars": 3287,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/from/rounding_from.rs",
"chars": 5363,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/from/saturating_from.rs",
"chars": 3268,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/from/try_from_and_exact_from.rs",
"chars": 12087,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/from/wrapping_from.rs",
"chars": 3215,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/half/join_halves.rs",
"chars": 2116,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/half/lower_half.rs",
"chars": 1757,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/half/mod.rs",
"chars": 680,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/half/split_in_half.rs",
"chars": 1783,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/half/upper_half.rs",
"chars": 1757,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/is_integer.rs",
"chars": 3807,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/mantissa_and_exponent/integer_mantissa_and_exponent.rs",
"chars": 13872,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/mantissa_and_exponent/mod.rs",
"chars": 720,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/mantissa_and_exponent/raw_mantissa_and_exponent.rs",
"chars": 5278,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/mantissa_and_exponent/sci_mantissa_and_exponent.rs",
"chars": 19355,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/mod.rs",
"chars": 794,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
},
{
"path": "malachite-base/src/bin_util/demo_and_bench/num/conversion/slice/from_other_type_slice.rs",
"chars": 2023,
"preview": "// Copyright © 2026 Mikhail Hogrefe\n//\n// This file is part of Malachite.\n//\n// Malachite is free software: you can redi"
}
]
// ... and 2507 more files (download for full content)
About this extraction
This page contains the full source code of the mhogrefe/malachite GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2707 files (35.5 MB), approximately 9.5M tokens, and a symbol index with 27002 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.