SYMBOL INDEX (3217 symbols across 389 files)

FILE: .github/workflows/scripts/build_directory/src/lib.rs
  function good_filepaths (line 9) | fn good_filepaths(top_dir: &Path) -> Result<Vec<String>, Box<dyn Error>> {
  function md_prefix (line 41) | fn md_prefix(indent_count: usize) -> String {
  function print_path (line 49) | fn print_path(old_path: String, new_path: String) -> (String, String) {
  function build_directory_md (line 63) | pub fn build_directory_md(top_dir: &Path) -> Result<String, Box<dyn Erro...
  function to_title (line 86) | fn to_title(name: &str) -> String {
  function get_addr (line 106) | fn get_addr(addr: &str) -> String {
  function switch_backslash (line 115) | fn switch_backslash(addr: &str) -> String {

FILE: .github/workflows/scripts/build_directory/src/main.rs
  function main (line 4) | fn main() -> Result<(), std::io::Error> {

FILE: src/backtracking/all_combination_of_size_k.rs
  type CombinationError (line 6) | pub enum CombinationError {
  function generate_all_combinations (line 22) | pub fn generate_all_combinations(n: usize, k: usize) -> Result<Vec<Vec<u...
  function backtrack (line 47) | fn backtrack(

FILE: src/backtracking/graph_coloring.rs
  type GraphColoringError (line 7) | pub enum GraphColoringError {
  function generate_colorings (line 25) | pub fn generate_colorings(
  type GraphColoring (line 33) | struct GraphColoring {
    method new (line 52) | fn new(adjacency_matrix: Vec<Vec<bool>>) -> Result<Self, GraphColoring...
    method num_vertices (line 73) | fn num_vertices(&self) -> usize {
    method is_color_valid (line 87) | fn is_color_valid(&self, vertex: usize, color: usize) -> bool {
    method find_colorings (line 105) | fn find_colorings(&mut self, vertex: usize, num_colors: usize) {
    method find_solutions (line 129) | fn find_solutions(&mut self, num_colors: usize) -> Option<Vec<Vec<usiz...

FILE: src/backtracking/hamiltonian_cycle.rs
  type FindHamiltonianCycleError (line 6) | pub enum FindHamiltonianCycleError {
  type Graph (line 16) | struct Graph {
    method new (line 33) | fn new(adjacency_matrix: Vec<Vec<bool>>) -> Result<Self, FindHamiltoni...
    method num_vertices (line 51) | fn num_vertices(&self) -> usize {
    method is_safe (line 67) | fn is_safe(&self, v: usize, visited: &[bool], path: &[Option<usize>], ...
    method hamiltonian_cycle_util (line 90) | fn hamiltonian_cycle_util(
    method find_hamiltonian_cycle (line 131) | fn find_hamiltonian_cycle(
  function find_hamiltonian_cycle (line 160) | pub fn find_hamiltonian_cycle(

FILE: src/backtracking/knight_tour.rs
  function find_knight_tour (line 20) | pub fn find_knight_tour(
  type KnightTour (line 31) | struct KnightTour {
    constant MOVES (line 37) | const MOVES: [(isize, isize); 8] = [
    method new (line 57) | fn new(size_x: usize, size_y: usize) -> Self {
    method size_x (line 63) | fn size_x(&self) -> usize {
    method size_y (line 68) | fn size_y(&self) -> usize {
    method is_safe (line 82) | fn is_safe(&self, x: isize, y: isize) -> bool {
    method solve_tour (line 101) | fn solve_tour(&mut self, x: isize, y: isize, move_count: usize) -> bool {
    method find_tour (line 133) | fn find_tour(&mut self, start_x: usize, start_y: usize) -> Option<Vec<...

FILE: src/backtracking/n_queens.rs
  function n_queens_solver (line 22) | pub fn n_queens_solver(n: usize) -> Vec<Vec<String>> {
  type NQueensSolver (line 28) | struct NQueensSolver {
    method new (line 47) | fn new(size: usize) -> Self {
    method solve (line 60) | fn solve(&mut self) -> Vec<Vec<String>> {
    method is_safe (line 75) | fn is_safe(&self, row: usize, col: usize) -> bool {
    method solve_helper (line 93) | fn solve_helper(&mut self, row: usize) {

FILE: src/backtracking/parentheses_generator.rs
  function generate_parentheses (line 9) | pub fn generate_parentheses(n: usize) -> Vec<String> {
  function generate (line 30) | fn generate(

FILE: src/backtracking/permutations.rs
  function permute (line 14) | pub fn permute(mut nums: Vec<isize>) -> Vec<Vec<isize>> {
  function generate (line 33) | fn generate(

FILE: src/backtracking/rat_in_maze.rs
  type MazeError (line 9) | pub enum MazeError {
  function find_path_in_maze (line 43) | pub fn find_path_in_maze(
  type Maze (line 68) | struct Maze {
    constant MOVES (line 74) | const MOVES: [(isize, isize); 4] = [(0, 1), (1, 0), (0, -1), (-1, 0)];
    method new (line 85) | fn new(maze: Vec<Vec<bool>>) -> Self {
    method width (line 94) | fn width(&self) -> usize {
    method height (line 103) | fn height(&self) -> usize {
    method find_path (line 117) | fn find_path(&self, start_x: usize, start_y: usize) -> Option<Vec<Vec<...
    method solve (line 137) | fn solve(&self, x: isize, y: isize, solution: &mut [Vec<bool>]) -> bool {
    method is_valid (line 170) | fn is_valid(&self, x: isize, y: isize, solution: &[Vec<bool>]) -> bool {

FILE: src/backtracking/subset_sum.rs
  function has_subset_with_sum (line 5) | pub fn has_subset_with_sum(set: &[isize], target: isize) -> bool {
  function backtrack (line 9) | fn backtrack(set: &[isize], remaining_items: usize, target: isize) -> bo...

FILE: src/backtracking/sudoku.rs
  function sudoku_solver (line 13) | pub fn sudoku_solver(board: &[[u8; 9]; 9]) -> Option<[[u8; 9]; 9]> {
  type SudokuSolver (line 23) | struct SudokuSolver {
    method new (line 30) | fn new(board: [[u8; 9]; 9]) -> SudokuSolver {
    method find_empty_cell (line 37) | fn find_empty_cell(&self) -> Option<(usize, usize)> {
    method is_value_valid (line 53) | fn is_value_valid(&self, coordinates: (usize, usize), value: u8) -> bo...
    method solve (line 89) | fn solve(&mut self) -> bool {

FILE: src/big_integer/fast_factorial.rs
  function index (line 10) | fn index(p: usize, n: usize) -> usize {
  function fast_factorial (line 25) | pub fn fast_factorial(n: usize) -> BigUint {
  function fact (line 68) | fn fact() {

FILE: src/big_integer/multiply.rs
  function multiply (line 2) | pub fn multiply(num1: &str, num2: &str) -> String {
  function is_valid_nonnegative (line 28) | pub fn is_valid_nonnegative(num: &str) -> bool {

FILE: src/big_integer/poly1305.rs
  type Poly1305 (line 17) | pub struct Poly1305 {
    method new (line 32) | pub fn new() -> Self {
    method clamp_r (line 40) | pub fn clamp_r(&mut self) {
    method set_key (line 43) | pub fn set_key(&mut self, key: &[u8; 32]) {
    method add_msg (line 51) | pub fn add_msg(&mut self, msg: &[u8; 16], msg_bytes: u64) {
    method get_tag (line 59) | pub fn get_tag(&self) -> Vec<u8> {
  method default (line 26) | fn default() -> Self {
  function get_tag_hex (line 71) | fn get_tag_hex(tag: &[u8]) -> String {
  function basic_tv1 (line 79) | fn basic_tv1() {

FILE: src/bit_manipulation/binary_coded_decimal.rs
  function binary_coded_decimal (line 50) | pub fn binary_coded_decimal(number: i32) -> String {
  function test_zero (line 73) | fn test_zero() {
  function test_single_digit (line 78) | fn test_single_digit() {
  function test_two_digits (line 91) | fn test_two_digits() {
  function test_three_digits (line 99) | fn test_three_digits() {
  function test_large_numbers (line 107) | fn test_large_numbers() {
  function test_negative_numbers (line 113) | fn test_negative_numbers() {
  function test_each_digit_encoding (line 121) | fn test_each_digit_encoding() {

FILE: src/bit_manipulation/binary_count_trailing_zeros.rs
  function binary_count_trailing_zeros (line 21) | pub fn binary_count_trailing_zeros(num: u64) -> u32 {
  function binary_count_trailing_zeros_bitwise (line 47) | pub fn binary_count_trailing_zeros_bitwise(num: u64) -> u32 {
  function test_basic_cases (line 61) | fn test_basic_cases() {
  function test_zero (line 70) | fn test_zero() {
  function test_powers_of_two (line 75) | fn test_powers_of_two() {
  function test_bitwise_vs_builtin (line 84) | fn test_bitwise_vs_builtin() {

FILE: src/bit_manipulation/binary_shifts.rs
  function logical_left_shift (line 54) | pub fn logical_left_shift(number: i32, shift_amount: i32) -> Result<Stri...
  function logical_right_shift (line 94) | pub fn logical_right_shift(number: i32, shift_amount: i32) -> Result<Str...
  function arithmetic_right_shift (line 131) | pub fn arithmetic_right_shift(number: i32, shift_amount: i32) -> Result<...
  function arithmetic_left_shift (line 220) | pub fn arithmetic_left_shift(number: i32, shift_amount: i32) -> Result<S...
  function test_logical_left_shift_zero (line 238) | fn test_logical_left_shift_zero() {
  function test_logical_left_shift_one (line 243) | fn test_logical_left_shift_one() {
  function test_logical_left_shift_large_shift (line 248) | fn test_logical_left_shift_large_shift() {
  function test_logical_left_shift_seventeen (line 253) | fn test_logical_left_shift_seventeen() {
  function test_logical_left_shift_large_number (line 258) | fn test_logical_left_shift_large_number() {
  function test_logical_left_shift_negative_number (line 263) | fn test_logical_left_shift_negative_number() {
  function test_logical_left_shift_negative_shift (line 268) | fn test_logical_left_shift_negative_shift() {
  function test_logical_left_shift_both_negative (line 273) | fn test_logical_left_shift_both_negative() {
  function test_logical_right_shift_zero (line 279) | fn test_logical_right_shift_zero() {
  function test_logical_right_shift_one (line 284) | fn test_logical_right_shift_one() {
  function test_logical_right_shift_shift_all_bits (line 289) | fn test_logical_right_shift_shift_all_bits() {
  function test_logical_right_shift_seventeen (line 294) | fn test_logical_right_shift_seventeen() {
  function test_logical_right_shift_large_number (line 299) | fn test_logical_right_shift_large_number() {
  function test_logical_right_shift_negative_number (line 304) | fn test_logical_right_shift_negative_number() {
  function test_logical_right_shift_negative_shift (line 309) | fn test_logical_right_shift_negative_shift() {
  function test_logical_right_shift_both_negative (line 314) | fn test_logical_right_shift_both_negative() {
  function test_arithmetic_right_shift_zero (line 320) | fn test_arithmetic_right_shift_zero() {
  function test_arithmetic_right_shift_one (line 325) | fn test_arithmetic_right_shift_one() {
  function test_arithmetic_right_shift_negative_one (line 330) | fn test_arithmetic_right_shift_negative_one() {
  function test_arithmetic_right_shift_seventeen_positive (line 335) | fn test_arithmetic_right_shift_seventeen_positive() {
  function test_arithmetic_right_shift_seventeen_negative (line 340) | fn test_arithmetic_right_shift_seventeen_negative() {
  function test_arithmetic_right_shift_large_negative (line 345) | fn test_arithmetic_right_shift_large_negative() {
  function test_arithmetic_right_shift_negative_shift (line 350) | fn test_arithmetic_right_shift_negative_shift() {
  function test_arithmetic_right_shift_preserves_sign_positive (line 355) | fn test_arithmetic_right_shift_preserves_sign_positive() {
  function test_arithmetic_right_shift_preserves_sign_negative (line 364) | fn test_arithmetic_right_shift_preserves_sign_negative() {
  function test_arithmetic_right_shift_large_shift_positive (line 371) | fn test_arithmetic_right_shift_large_shift_positive() {
  function test_arithmetic_right_shift_large_shift_negative (line 379) | fn test_arithmetic_right_shift_large_shift_negative() {
  function test_arithmetic_left_shift_basic (line 390) | fn test_arithmetic_left_shift_basic() {
  function test_arithmetic_left_shift_negative (line 396) | fn test_arithmetic_left_shift_negative() {
  function test_arithmetic_left_shift_zero (line 406) | fn test_arithmetic_left_shift_zero() {
  function test_arithmetic_left_shift_negative_shift (line 411) | fn test_arithmetic_left_shift_negative_shift() {
  function test_arithmetic_left_shift_same_as_logical (line 416) | fn test_arithmetic_left_shift_same_as_logical() {
  function test_all_shifts_on_same_value (line 430) | fn test_all_shifts_on_same_value() {

FILE: src/bit_manipulation/counting_bits.rs
  function count_set_bits (line 16) | pub fn count_set_bits(mut n: usize) -> usize {

FILE: src/bit_manipulation/find_missing_number.rs
  function find_missing_number (line 27) | pub fn find_missing_number(nums: &[i32]) -> Result<i32, String> {
  function test_missing_in_middle (line 54) | fn test_missing_in_middle() {
  function test_unordered_array (line 59) | fn test_unordered_array() {
  function test_negative_numbers (line 64) | fn test_negative_numbers() {
  function test_negative_and_positive (line 69) | fn test_negative_and_positive() {
  function test_missing_at_start (line 74) | fn test_missing_at_start() {
  function test_unordered_missing_middle (line 79) | fn test_unordered_missing_middle() {
  function test_another_unordered (line 84) | fn test_another_unordered() {
  function test_empty_array (line 89) | fn test_empty_array() {
  function test_single_element (line 98) | fn test_single_element() {
  function test_two_elements (line 107) | fn test_two_elements() {
  function test_large_range (line 113) | fn test_large_range() {
  function test_missing_at_boundaries (line 118) | fn test_missing_at_boundaries() {

FILE: src/bit_manipulation/find_previous_power_of_two.rs
  function find_previous_power_of_two (line 53) | pub fn find_previous_power_of_two(number: i32) -> Result<u32, String> {
  function test_zero (line 77) | fn test_zero() {
  function test_one (line 82) | fn test_one() {
  function test_powers_of_two (line 87) | fn test_powers_of_two() {
  function test_numbers_between_powers (line 101) | fn test_numbers_between_powers() {
  function test_range_0_to_17 (line 126) | fn test_range_0_to_17() {
  function test_large_numbers (line 136) | fn test_large_numbers() {
  function test_max_safe_values (line 145) | fn test_max_safe_values() {
  function test_negative_number_returns_error (line 152) | fn test_negative_number_returns_error() {
  function test_negative_numbers_return_errors (line 159) | fn test_negative_numbers_return_errors() {
  function test_edge_cases (line 166) | fn test_edge_cases() {

FILE: src/bit_manipulation/find_unique_number.rs
  function find_unique_number (line 26) | pub fn find_unique_number(arr: &[i32]) -> Result<i32, String> {
  function test_basic_case (line 40) | fn test_basic_case() {
  function test_different_order (line 45) | fn test_different_order() {
  function test_single_element (line 50) | fn test_single_element() {
  function test_three_elements (line 55) | fn test_three_elements() {
  function test_empty_array (line 60) | fn test_empty_array() {
  function test_negative_numbers (line 69) | fn test_negative_numbers() {
  function test_large_numbers (line 74) | fn test_large_numbers() {
  function test_zero (line 82) | fn test_zero() {

FILE: src/bit_manipulation/hamming_distance.rs
  function bit_count (line 25) | fn bit_count(mut value: u64) -> u64 {
  function hamming_distance (line 59) | pub fn hamming_distance(a: u64, b: u64) -> u64 {
  function hamming_distance_str (line 89) | pub fn hamming_distance_str(a: &str, b: &str) -> u64 {
  function test_bit_count (line 107) | fn test_bit_count() {
  function test_hamming_distance_integers (line 114) | fn test_hamming_distance_integers() {
  function test_hamming_distance_strings (line 122) | fn test_hamming_distance_strings() {
  function test_hamming_distance_strings_different_lengths (line 133) | fn test_hamming_distance_strings_different_lengths() {

FILE: src/bit_manipulation/highest_set_bit.rs
  function find_highest_set_bit (line 13) | pub fn find_highest_set_bit(num: usize) -> Option<usize> {

FILE: src/bit_manipulation/is_power_of_two.rs
  function is_power_of_two (line 70) | pub fn is_power_of_two(number: i32) -> Result<bool, String> {
  function test_zero (line 88) | fn test_zero() {
  function test_one (line 94) | fn test_one() {
  function test_powers_of_two (line 100) | fn test_powers_of_two() {
  function test_non_powers_of_two (line 120) | fn test_non_powers_of_two() {
  function test_specific_non_powers (line 137) | fn test_specific_non_powers() {
  function test_large_powers_of_two (line 145) | fn test_large_powers_of_two() {
  function test_numbers_near_powers_of_two (line 153) | fn test_numbers_near_powers_of_two() {
  function test_negative_number_returns_error (line 174) | fn test_negative_number_returns_error() {
  function test_multiple_negative_numbers (line 181) | fn test_multiple_negative_numbers() {
  function test_all_powers_of_two_up_to_30 (line 190) | fn test_all_powers_of_two_up_to_30() {
  function test_range_verification (line 202) | fn test_range_verification() {
  function test_bit_manipulation_correctness (line 220) | fn test_bit_manipulation_correctness() {
  function test_edge_case_max_i32_power_of_two (line 236) | fn test_edge_case_max_i32_power_of_two() {

FILE: src/bit_manipulation/n_bits_gray_code.rs
  type GrayCodeError (line 3) | pub enum GrayCodeError {
  function generate_gray_code (line 16) | pub fn generate_gray_code(n: usize) -> Result<Vec<String>, GrayCodeError> {

FILE: src/bit_manipulation/reverse_bits.rs
  function reverse_bits (line 60) | pub fn reverse_bits(n: u32) -> u32 {
  function test_reverse_bits_basic (line 84) | fn test_reverse_bits_basic() {
  function test_reverse_bits_one (line 91) | fn test_reverse_bits_one() {
  function test_reverse_bits_all_ones (line 98) | fn test_reverse_bits_all_ones() {
  function test_reverse_bits_zero (line 105) | fn test_reverse_bits_zero() {
  function test_reverse_bits_max (line 112) | fn test_reverse_bits_max() {
  function test_reverse_bits_alternating (line 119) | fn test_reverse_bits_alternating() {
  function test_reverse_bits_symmetric (line 126) | fn test_reverse_bits_symmetric() {

FILE: src/bit_manipulation/rightmost_set_bit.rs
  function index_of_rightmost_set_bit (line 41) | pub fn index_of_rightmost_set_bit(num: i32) -> Result<u32, String> {
  function index_of_rightmost_set_bit_log (line 69) | pub fn index_of_rightmost_set_bit_log(num: i32) -> Result<u32, String> {
  function test_basic_cases (line 88) | fn test_basic_cases() {
  function test_powers_of_two (line 100) | fn test_powers_of_two() {
  function test_odd_numbers (line 121) | fn test_odd_numbers() {
  function test_even_numbers (line 131) | fn test_even_numbers() {
  function test_zero (line 143) | fn test_zero() {
  function test_negative_numbers (line 152) | fn test_negative_numbers() {
  function test_large_numbers (line 162) | fn test_large_numbers() {
  function test_consecutive_numbers (line 174) | fn test_consecutive_numbers() {
  function test_log_version (line 183) | fn test_log_version() {
  function test_both_implementations_match (line 192) | fn test_both_implementations_match() {

FILE: src/bit_manipulation/sum_of_two_integers.rs
  function add_two_integers (line 14) | pub fn add_two_integers(mut a: isize, mut b: isize) -> isize {

FILE: src/bit_manipulation/swap_odd_even_bits.rs
  function swap_odd_even_bits (line 28) | pub fn swap_odd_even_bits(num: u32) -> u32 {
  function test_swap_odd_even_bits (line 44) | fn test_swap_odd_even_bits() {
  function test_edge_cases (line 57) | fn test_edge_cases() {
  function test_power_of_two (line 67) | fn test_power_of_two() {

FILE: src/bit_manipulation/twos_complement.rs
  function twos_complement (line 43) | pub fn twos_complement(number: i32) -> Result<String, String> {
  function test_zero (line 78) | fn test_zero() {
  function test_negative_one (line 83) | fn test_negative_one() {
  function test_negative_five (line 88) | fn test_negative_five() {
  function test_negative_seventeen (line 93) | fn test_negative_seventeen() {
  function test_negative_two_hundred_seven (line 98) | fn test_negative_two_hundred_seven() {
  function test_negative_small_values (line 103) | fn test_negative_small_values() {
  function test_negative_larger_values (line 110) | fn test_negative_larger_values() {
  function test_positive_number_returns_error (line 117) | fn test_positive_number_returns_error() {
  function test_large_positive_number_returns_error (line 124) | fn test_large_positive_number_returns_error() {
  function test_edge_case_negative_powers_of_two (line 131) | fn test_edge_case_negative_powers_of_two() {

FILE: src/ciphers/aes.rs
  constant AES_WORD_SIZE (line 1) | const AES_WORD_SIZE: usize = 4;
  constant AES_BLOCK_SIZE (line 2) | const AES_BLOCK_SIZE: usize = 16;
  constant AES_NUM_BLOCK_WORDS (line 3) | const AES_NUM_BLOCK_WORDS: usize = AES_BLOCK_SIZE / AES_WORD_SIZE;
  type Byte (line 5) | type Byte = u8;
  type Word (line 6) | type Word = u32;
  type AesWord (line 8) | type AesWord = [Byte; AES_WORD_SIZE];
  constant RCON (line 12) | const RCON: [Word; 256] = [
  constant SBOX (line 34) | const SBOX: [Byte; 256] = [
  constant INV_SBOX (line 56) | const INV_SBOX: [Byte; 256] = [
  constant GF_MUL_TABLE (line 77) | const GF_MUL_TABLE: [[Byte; 256]; 16] = [
  type AesKey (line 222) | pub enum AesKey {
  type AesMode (line 229) | enum AesMode {
  function aes_encrypt (line 234) | pub fn aes_encrypt(plain_text: &[Byte], key: AesKey) -> Vec<Byte> {
  function aes_decrypt (line 263) | pub fn aes_decrypt(cipher_text: &[Byte], key: AesKey) -> Vec<Byte> {
  function key_expansion (line 292) | fn key_expansion(init_key: &[Byte], num_rounds: usize) -> Vec<Byte> {
  function add_round_key (line 320) | fn add_round_key(data: &mut [Byte], round_key: &[Byte]) {
  function sub_bytes_blocks (line 328) | fn sub_bytes_blocks(data: &mut [Byte], mode: AesMode) {
  function shift_rows_blocks (line 334) | fn shift_rows_blocks(blocks: &mut [Byte], mode: AesMode) {
  function mix_column_blocks (line 342) | fn mix_column_blocks(data: &mut [Byte], mode: AesMode) {
  function padding (line 350) | fn padding<T: Clone + Default>(data: &[T], block_size: usize) -> Vec<T> {
  function sub_word (line 364) | fn sub_word(word: Word, mode: AesMode) -> Word {
  function sub_bytes (line 370) | fn sub_bytes(data: &mut [Byte], mode: AesMode) {
  function shift_rows (line 380) | fn shift_rows(block: &mut [Byte], mode: AesMode) {
  function mix_column (line 394) | fn mix_column(block: &mut [Byte], mode: AesMode) {
  function transpose_block (line 426) | fn transpose_block(block: &mut [u8]) {
  function bytes_to_word (line 436) | fn bytes_to_word(bytes: &[Byte]) -> Word {
  function word_to_bytes (line 445) | fn word_to_bytes(word: Word) -> AesWord {
  function rot_word (line 454) | fn rot_word(word: Word) -> Word {
  function test_aes_128 (line 469) | fn test_aes_128() {
  function test_aes_192 (line 489) | fn test_aes_192() {
  function test_aes_256 (line 509) | fn test_aes_256() {
  function test_str (line 530) | fn test_str() {

FILE: src/ciphers/affine_cipher.rs
  constant SYMBOLS (line 30) | const SYMBOLS: &str = r##" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM...
  function gcd (line 42) | fn gcd(mut a: usize, mut b: usize) -> usize {
  function find_mod_inverse (line 64) | fn find_mod_inverse(a: i64, m: i64) -> Option<i64> {
  function check_keys (line 106) | fn check_keys(key_a: usize, key_b: usize, is_encrypt: bool) -> Result<()...
  function affine_encrypt (line 160) | pub fn affine_encrypt(key: usize, message: &str) -> Result<String, Strin...
  function affine_decrypt (line 201) | pub fn affine_decrypt(key: usize, message: &str) -> Result<String, Strin...
  function affine_generate_key (line 246) | pub fn affine_generate_key() -> usize {
  function test_gcd (line 266) | fn test_gcd() {
  function test_find_mod_inverse (line 276) | fn test_find_mod_inverse() {
  function test_encrypt_decrypt_example (line 284) | fn test_encrypt_decrypt_example() {
  function test_encrypt_simple (line 299) | fn test_encrypt_simple() {
  function test_roundtrip_various_messages (line 313) | fn test_roundtrip_various_messages() {
  function test_empty_string (line 331) | fn test_empty_string() {
  function test_invalid_key_a_is_one (line 341) | fn test_invalid_key_a_is_one() {
  function test_invalid_key_b_is_zero (line 351) | fn test_invalid_key_b_is_zero() {
  function test_invalid_key_not_coprime (line 361) | fn test_invalid_key_not_coprime() {
  function test_key_b_too_large (line 372) | fn test_key_b_too_large() {
  function test_symbols_not_in_set (line 384) | fn test_symbols_not_in_set() {
  function test_generate_key (line 398) | fn test_generate_key() {
  function test_generate_key_validity (line 409) | fn test_generate_key_validity() {
  function test_all_symbols (line 426) | fn test_all_symbols() {
  function test_different_keys_produce_different_ciphertexts (line 439) | fn test_different_keys_produce_different_ciphertexts() {
  function test_long_message (line 451) | fn test_long_message() {

FILE: src/ciphers/another_rot13.rs
  function another_rot13 (line 1) | pub fn another_rot13(text: &str) -> String {
  function test_simple (line 18) | fn test_simple() {
  function test_every_alphabet_with_space (line 23) | fn test_every_alphabet_with_space() {
  function test_non_alphabet (line 31) | fn test_non_alphabet() {

FILE: src/ciphers/baconian_cipher.rs
  function baconian_encode (line 8) | pub fn baconian_encode(message: &str) -> String {
  function baconian_decode (line 29) | pub fn baconian_decode(encoded: &str) -> String {
  function test_baconian_encoding (line 58) | fn test_baconian_encoding() {
  function test_baconian_decoding (line 65) | fn test_baconian_decoding() {

FILE: src/ciphers/base16.rs
  function base16_encode (line 31) | pub fn base16_encode(data: &[u8]) -> String {
  function base16_decode (line 78) | pub fn base16_decode(data: &str) -> Result<Vec<u8>, String> {
  function test_encode_hello_world (line 119) | fn test_encode_hello_world() {
  function test_encode_hello_world_uppercase (line 124) | fn test_encode_hello_world_uppercase() {
  function test_encode_empty (line 129) | fn test_encode_empty() {
  function test_encode_special_characters (line 134) | fn test_encode_special_characters() {
  function test_encode_all_bytes (line 139) | fn test_encode_all_bytes() {
  function test_decode_hello_world (line 146) | fn test_decode_hello_world() {
  function test_decode_hello_world_uppercase (line 154) | fn test_decode_hello_world_uppercase() {
  function test_decode_empty (line 162) | fn test_decode_empty() {
  function test_decode_special_characters (line 167) | fn test_decode_special_characters() {
  function test_decode_odd_length (line 172) | fn test_decode_odd_length() {
  function test_decode_lowercase_hex (line 181) | fn test_decode_lowercase_hex() {
  function test_decode_invalid_characters (line 190) | fn test_decode_invalid_characters() {
  function test_decode_mixed_case (line 199) | fn test_decode_mixed_case() {
  function test_roundtrip (line 205) | fn test_roundtrip() {
  function test_roundtrip_all_bytes (line 213) | fn test_roundtrip_all_bytes() {
  function test_roundtrip_empty (line 221) | fn test_roundtrip_empty() {

FILE: src/ciphers/base32.rs
  constant B32_CHARSET (line 9) | const B32_CHARSET: &[u8; 32] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
  function base32_encode (line 32) | pub fn base32_encode(data: &[u8]) -> Vec<u8> {
  function base32_decode (line 93) | pub fn base32_decode(data: &[u8]) -> Result<Vec<u8>, String> {
  function test_encode_hello_world (line 136) | fn test_encode_hello_world() {
  function test_encode_numbers (line 141) | fn test_encode_numbers() {
  function test_encode_long_string (line 146) | fn test_encode_long_string() {
  function test_encode_empty (line 154) | fn test_encode_empty() {
  function test_encode_single_char (line 159) | fn test_encode_single_char() {
  function test_decode_hello_world (line 164) | fn test_decode_hello_world() {
  function test_decode_numbers (line 172) | fn test_decode_numbers() {
  function test_decode_long_string (line 177) | fn test_decode_long_string() {
  function test_decode_empty (line 185) | fn test_decode_empty() {
  function test_decode_single_char (line 190) | fn test_decode_single_char() {
  function test_decode_without_padding (line 195) | fn test_decode_without_padding() {
  function test_decode_invalid_character (line 203) | fn test_decode_invalid_character() {
  function test_roundtrip_hello (line 210) | fn test_roundtrip_hello() {
  function test_roundtrip_various_strings (line 218) | fn test_roundtrip_various_strings() {
  function test_all_charset_characters (line 238) | fn test_all_charset_characters() {
  function test_binary_data (line 249) | fn test_binary_data() {
  function test_padding_variations (line 257) | fn test_padding_variations() {

FILE: src/ciphers/base64.rs
  constant CHARSET (line 7) | const CHARSET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopq...
  constant PADDING (line 8) | const PADDING: char = '=';
  function collect_six_bits (line 29) | fn collect_six_bits(from: (u8, u8), offset: u8) -> u8 {
  function base64_encode (line 34) | pub fn base64_encode(data: &[u8]) -> String {
  function base64_decode (line 64) | pub fn base64_decode(data: &str) -> Result<Vec<u8>, (&str, u8)> {
  function pregenerated_random_bytes_encode (line 104) | fn pregenerated_random_bytes_encode() {
  function pregenerated_random_bytes_decode (line 170) | fn pregenerated_random_bytes_decode() {
  function encode_decode (line 239) | fn encode_decode() {
  function decode_encode (line 259) | fn decode_encode() {

FILE: src/ciphers/base85.rs
  function base10_to_85 (line 10) | fn base10_to_85(mut d: u32) -> String {
  function base85_to_10 (line 24) | fn base85_to_10(digits: &[u8]) -> u32 {
  function base85_encode (line 49) | pub fn base85_encode(data: &[u8]) -> Vec<u8> {
  function base85_decode (line 111) | pub fn base85_decode(data: &[u8]) -> Vec<u8> {
  function test_encode_empty (line 169) | fn test_encode_empty() {
  function test_encode_12345 (line 174) | fn test_encode_12345() {
  function test_encode_base85 (line 179) | fn test_encode_base85() {
  function test_decode_empty (line 184) | fn test_decode_empty() {
  function test_decode_12345 (line 189) | fn test_decode_12345() {
  function test_decode_base85 (line 194) | fn test_decode_base85() {
  function test_encode_decode_roundtrip (line 199) | fn test_encode_decode_roundtrip() {

FILE: src/ciphers/blake2b.rs
  type Word (line 6) | type Word = u64;
  constant BB (line 8) | const BB: usize = 128;
  constant U64BYTES (line 10) | const U64BYTES: usize = (u64::BITS as usize) / 8;
  type Block (line 12) | type Block = [Word; BB / U64BYTES];
  constant KK_MAX (line 14) | const KK_MAX: usize = 64;
  constant NN_MAX (line 15) | const NN_MAX: u8 = 64;
  constant RC (line 18) | const RC: [u32; 4] = [32, 24, 16, 63];
  constant IV (line 21) | const IV: [Word; 8] = [
  constant SIGMA (line 32) | const SIGMA: [[usize; 16]; 10] = [
  function blank_block (line 46) | const fn blank_block() -> Block {
  function add (line 52) | fn add(a: &mut Word, b: Word) {
  function ceil (line 57) | const fn ceil(dividend: usize, divisor: usize) -> usize {
  function g (line 61) | fn g(v: &mut [Word; 16], a: usize, b: usize, c: usize, d: usize, x: Word...
  function f (line 76) | fn f(h: &mut [Word; 8], m: Block, t: u128, flag: bool) {
  function blake2 (line 139) | fn blake2(d: Vec<Block>, ll: u128, kk: Word, nn: Word) -> Vec<u8> {
  function bytes_to_word (line 166) | fn bytes_to_word(bytes: &[u8]) -> Word {
  function blake2b (line 179) | pub fn blake2b(m: &[u8], k: &[u8], nn: u8) -> Vec<u8> {

FILE: src/ciphers/caesar.rs
  constant ERROR_MESSAGE (line 1) | const ERROR_MESSAGE: &str = "Rotation must be in the range [0, 25]";
  constant ALPHABET_LENGTH (line 2) | const ALPHABET_LENGTH: u8 = b'z' - b'a' + 1;
  function caesar (line 24) | pub fn caesar(text: &str, rotation: isize) -> Result<String, &'static st...
  function shift_char (line 53) | fn shift_char(c: char, rotation: isize) -> char {
  function alphabet_length_should_be_26 (line 92) | fn alphabet_length_should_be_26() {

FILE: src/ciphers/chacha.rs
  constant C (line 16) | pub const C: [u32; 4] = [0x61707865, 0x3320646e, 0x79622d32, 0x6b206574];
  function chacha20 (line 86) | pub fn chacha20(input: &[u32; 16], output: &mut [u32; 16]) {
  function output_hex (line 111) | fn output_hex(inp: &[u32; 16]) -> String {
  function basic_tv1 (line 122) | fn basic_tv1() {

FILE: src/ciphers/diffie_hellman.rs
  function rand (line 198) | fn rand() -> usize {
  type DiffieHellman (line 205) | pub struct DiffieHellman {
    method new (line 230) | pub fn new(group: Option<u8>) -> Self {
    method get_private_key (line 249) | pub fn get_private_key(&self) -> String {
    method generate_public_key (line 254) | pub fn generate_public_key(&mut self) -> String {
    method is_valid_public_key (line 259) | pub fn is_valid_public_key(&self, key_str: &str) -> bool {
    method generate_shared_key (line 280) | pub fn generate_shared_key(self, other_key_str: &str) -> Option<String> {
  function verify_invalid_pub_key (line 297) | fn verify_invalid_pub_key() {
  function verify_valid_pub_key (line 303) | fn verify_valid_pub_key() {
  function verify_invalid_pub_key_same_as_prime (line 309) | fn verify_invalid_pub_key_same_as_prime() {
  function verify_key_exchange (line 327) | fn verify_key_exchange() {

FILE: src/ciphers/hashing_traits.rs
  type Hasher (line 1) | pub trait Hasher<const DIGEST_BYTES: usize> {
    method new_default (line 3) | fn new_default() -> Self;
    method update (line 6) | fn update(&mut self, data: &[u8]);
    method get_hash (line 11) | fn get_hash(&mut self) -> [u8; DIGEST_BYTES];
  type HMAC (line 15) | pub struct HMAC<const KEY_BYTES: usize, const DIGEST_BYTES: usize, H: Ha...
  function new_default (line 23) | pub fn new_default() -> Self {
  function add_key (line 34) | pub fn add_key(&mut self, key: &[u8]) -> Result<(), &'static str> {
  function update (line 59) | pub fn update(&mut self, data: &[u8]) {
  function finalize (line 63) | pub fn finalize(&mut self) -> [u8; DIGEST_BYTES] {
  function sha256_basic (line 77) | fn sha256_basic() {

FILE: src/ciphers/hill_cipher.rs
  constant KEY_STRING (line 32) | const KEY_STRING: &str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  constant MODULUS (line 33) | const MODULUS: i32 = 36;
  type HillCipher (line 36) | pub struct HillCipher {
    method new (line 51) | pub fn new(mut encrypt_key: Vec<Vec<i32>>) -> Result<Self, String> {
    method replace_letter (line 82) | fn replace_letter(&self, letter: char) -> Option<usize> {
    method replace_digit (line 86) | fn replace_digit(&self, num: i32) -> char {
    method determinant (line 90) | fn determinant(matrix: &[Vec<i32>]) -> i32 {
    method get_minor (line 111) | fn get_minor(matrix: &[Vec<i32>], row: usize, col: usize) -> Vec<Vec<i...
    method cofactor_matrix (line 126) | fn cofactor_matrix(matrix: &[Vec<i32>]) -> Vec<Vec<i32>> {
    method transpose (line 141) | fn transpose(matrix: &[Vec<i32>]) -> Vec<Vec<i32>> {
    method mod_inverse (line 154) | fn mod_inverse(a: i32, m: i32) -> Option<i32> {
    method gcd (line 159) | fn gcd(mut a: i32, mut b: i32) -> i32 {
    method check_determinant (line 172) | fn check_determinant(&self) -> Result<(), String> {
    method process_text (line 185) | fn process_text(&self, text: &str) -> String {
    method encrypt (line 205) | pub fn encrypt(&self, text: &str) -> String {
    method make_decrypt_key (line 233) | fn make_decrypt_key(&self) -> Vec<Vec<i32>> {
    method decrypt (line 255) | pub fn decrypt(&self, text: &str) -> String {
  function test_encrypt (line 290) | fn test_encrypt() {
  function test_decrypt (line 298) | fn test_decrypt() {
  function test_encrypt_decrypt_roundtrip (line 306) | fn test_encrypt_decrypt_roundtrip() {
  function test_process_text (line 318) | fn test_process_text() {
  function test_replace_letter (line 329) | fn test_replace_letter() {
  function test_replace_digit (line 338) | fn test_replace_digit() {
  function test_invalid_determinant (line 347) | fn test_invalid_determinant() {
  function test_3x3_matrix (line 354) | fn test_3x3_matrix() {
  function test_gcd (line 364) | fn test_gcd() {
  function test_mod_inverse (line 371) | fn test_mod_inverse() {

FILE: src/ciphers/kernighan.rs
  function kernighan (line 1) | pub fn kernighan(n: u32) -> i32 {
  function count_set_bits (line 18) | fn count_set_bits() {

FILE: src/ciphers/morse_code.rs
  constant UNKNOWN_CHARACTER (line 4) | const UNKNOWN_CHARACTER: &str = "........";
  constant _UNKNOWN_MORSE_CHARACTER (line 5) | const _UNKNOWN_MORSE_CHARACTER: &str = "_";
  function encode (line 7) | pub fn encode(message: &str) -> String {
  function _morse_dictionary (line 25) | fn _morse_dictionary() -> HashMap<&'static str, &'static str> {
  function _morse_to_alphanumeric_dictionary (line 51) | fn _morse_to_alphanumeric_dictionary() -> HashMap<&'static str, &'static...
  function _check_part (line 77) | fn _check_part(string: &str) -> bool {
  function _check_all_parts (line 87) | fn _check_all_parts(string: &str) -> bool {
  function _decode_token (line 91) | fn _decode_token(string: &str) -> String {
  function _decode_part (line 98) | fn _decode_part(string: &str) -> String {
  function decode (line 106) | pub fn decode(string: &str) -> Result<String, io::Error> {
  function encrypt_only_letters (line 128) | fn encrypt_only_letters() {
  function encrypt_letters_and_special_characters (line 138) | fn encrypt_letters_and_special_characters() {
  function encrypt_message_with_unsupported_character (line 148) | fn encrypt_message_with_unsupported_character() {
  function decrypt_valid_morsecode_with_spaces (line 158) | fn decrypt_valid_morsecode_with_spaces() {
  function decrypt_valid_character_set_invalid_morsecode (line 169) | fn decrypt_valid_character_set_invalid_morsecode() {
  function decrypt_invalid_morsecode_with_spaces (line 181) | fn decrypt_invalid_morsecode_with_spaces() {

FILE: src/ciphers/polybius.rs
  function encode_ascii (line 3) | pub fn encode_ascii(string: &str) -> String {
  function decode_ascii (line 41) | pub fn decode_ascii(string: &str) -> String {
  function encode_empty (line 89) | fn encode_empty() {
  function encode_valid_string (line 94) | fn encode_valid_string() {
  function encode_emoji (line 99) | fn encode_emoji() {
  function decode_empty (line 104) | fn decode_empty() {
  function decode_valid_string (line 109) | fn decode_valid_string() {
  function decode_emoji (line 117) | fn decode_emoji() {
  function decode_string_with_whitespace (line 122) | fn decode_string_with_whitespace() {
  function decode_unknown_string (line 130) | fn decode_unknown_string() {
  function decode_odd_length (line 135) | fn decode_odd_length() {
  function encode_and_decode (line 140) | fn encode_and_decode() {

FILE: src/ciphers/rail_fence.rs
  function rail_fence_encrypt (line 2) | pub fn rail_fence_encrypt(plain_text: &str, key: usize) -> String {
  function rail_fence_decrypt (line 12) | pub fn rail_fence_decrypt(cipher: &str, key: usize) -> String {
  function zigzag (line 26) | fn zigzag(n: usize) -> impl Iterator<Item = usize> {
  function rails_basic (line 34) | fn rails_basic() {

FILE: src/ciphers/rot13.rs
  function rot13 (line 1) | pub fn rot13(text: &str) -> String {
  function test_single_letter (line 18) | fn test_single_letter() {
  function test_bunch_of_letters (line 23) | fn test_bunch_of_letters() {
  function test_non_ascii (line 28) | fn test_non_ascii() {
  function test_twice (line 33) | fn test_twice() {

FILE: src/ciphers/rsa_cipher.rs
  type PublicKey (line 25) | pub struct PublicKey {
  type PrivateKey (line 32) | pub struct PrivateKey {
  function gcd (line 47) | fn gcd(mut a: u64, mut b: u64) -> u64 {
  function mod_inverse (line 68) | fn mod_inverse(a: i64, m: i64) -> Option<u64> {
  function mod_pow (line 102) | fn mod_pow(mut base: u64, mut exp: u64, modulus: u64) -> u64 {
  function generate_keypair (line 148) | pub fn generate_keypair(p: u64, q: u64) -> (PublicKey, PrivateKey) {
  function encrypt (line 192) | pub fn encrypt(message: u64, public_key: &PublicKey) -> u64 {
  function decrypt (line 218) | pub fn decrypt(ciphertext: u64, private_key: &PrivateKey) -> u64 {
  function encrypt_text (line 243) | pub fn encrypt_text(message: &str, public_key: &PublicKey) -> Vec<u64> {
  function decrypt_text (line 271) | pub fn decrypt_text(ciphertext: &[u64], private_key: &PrivateKey) -> Str...
  function test_gcd (line 286) | fn test_gcd() {
  function test_mod_inverse (line 294) | fn test_mod_inverse() {
  function test_mod_pow (line 301) | fn test_mod_pow() {
  function test_generate_keypair (line 308) | fn test_generate_keypair() {
  function test_encrypt_decrypt_number (line 324) | fn test_encrypt_decrypt_number() {
  function test_encrypt_decrypt_various_numbers (line 337) | fn test_encrypt_decrypt_various_numbers() {
  function test_encrypt_decrypt_text (line 348) | fn test_encrypt_decrypt_text() {
  function test_encrypt_decrypt_longer_text (line 359) | fn test_encrypt_decrypt_longer_text() {
  function test_different_primes (line 370) | fn test_different_primes() {
  function test_encrypt_decrypt_alphabet (line 381) | fn test_encrypt_decrypt_alphabet() {
  function test_key_properties (line 392) | fn test_key_properties() {

FILE: src/ciphers/salsa.rs
  function salsa20 (line 61) | pub fn salsa20(input: &[u32; 16], output: &mut [u32; 16]) {
  constant C (line 86) | const C: [u32; 4] = [0x65787061, 0x6e642033, 0x322d6279, 0x7465206b];
  function output_hex (line 88) | fn output_hex(inp: &[u32; 16]) -> String {
  function basic_tv1 (line 98) | fn basic_tv1() {

FILE: src/ciphers/sha256.rs
  constant H0 (line 9) | pub const H0: [u32; 8] = [
  constant K (line 13) | pub const K: [u32; 64] = [
  function ch (line 26) | fn ch(x: u32, y: u32, z: u32) -> u32 {
  function maj (line 31) | fn maj(x: u32, y: u32, z: u32) -> u32 {
  function bsig0 (line 36) | fn bsig0(x: u32) -> u32 {
  function bsig1 (line 41) | fn bsig1(x: u32) -> u32 {
  function ssig0 (line 46) | fn ssig0(x: u32) -> u32 {
  function ssig1 (line 51) | fn ssig1(x: u32) -> u32 {
  type SHA256 (line 55) | pub struct SHA256 {
    method new_default (line 102) | pub fn new_default() -> Self {
    method process_block (line 113) | pub fn process_block(&mut self, buf: &[u32; 16]) {
    method update (line 118) | pub fn update(&mut self, data: &[u8]) {
    method get_hash (line 158) | pub fn get_hash(&mut self) -> [u8; 32] {
    method new_default (line 195) | fn new_default() -> Self {
    method update (line 199) | fn update(&mut self, data: &[u8]) {
    method get_hash (line 203) | fn get_hash(&mut self) -> [u8; 32] {
  function process_block (line 70) | fn process_block(h: &mut [u32; 8], w: &mut [u32; 64], round: &mut [u32; ...
  function get_hash_string (line 215) | pub fn get_hash_string(hash: &[u8; 32]) -> String {
  function test_constants (line 225) | fn test_constants() {
  function empty (line 258) | fn empty() {
  function ascii (line 271) | fn ascii() {
  function ascii_avalanche (line 285) | fn ascii_avalanche() {
  function long_ascii (line 307) | fn long_ascii() {
  function short_ascii (line 330) | fn short_ascii() {

FILE: src/ciphers/sha3.rs
  constant B (line 2) | const B: usize = 1600;
  constant W (line 4) | const W: usize = B / 25;
  constant L (line 5) | const L: usize = W.ilog2() as usize;
  constant U8BITS (line 7) | const U8BITS: usize = u8::BITS as usize;
  type PadFn (line 24) | type PadFn = fn(isize, isize) -> Vec<bool>;
  type SpongeFn (line 25) | type SpongeFn = fn(&[bool]) -> [bool; B];
  type State (line 27) | type State = [[[bool; W]; 5]; 5];
  function state_new (line 29) | fn state_new() -> State {
  function state_fill (line 33) | fn state_fill(dest: &mut State, bits: &[bool]) {
  function state_copy (line 43) | fn state_copy(dest: &mut State, src: &State) {
  function state_dump (line 49) | fn state_dump(state: &State) -> [bool; B] {
  function theta (line 63) | fn theta(state: &mut State) {
  function rho (line 95) | fn rho(state: &mut State) {
  function pi (line 122) | fn pi(state: &mut State) {
  function chi (line 132) | fn chi(state: &mut State) {
  function rc (line 143) | fn rc(t: u8) -> bool {
  function iota (line 174) | fn iota(state: &mut State, i_r: u8) {
  function rnd (line 186) | fn rnd(state: &mut State, i_r: u8) {
  function keccak_f (line 194) | fn keccak_f(bits: &[bool]) -> [bool; B] {
  function pad101 (line 207) | fn pad101(x: isize, m: isize) -> Vec<bool> {
  function sponge (line 226) | fn sponge(f: SpongeFn, pad: PadFn, r: usize, n: &[bool], d: usize) -> Ve...
  function keccak (line 252) | fn keccak(c: usize, n: &[bool], d: usize) -> Vec<bool> {
  function h2b (line 256) | fn h2b(h: &[u8], n: usize) -> Vec<bool> {
  function b2h (line 273) | fn b2h(s: &[bool]) -> Vec<u8> {

FILE: src/ciphers/tea.rs
  type TeaContext (line 3) | struct TeaContext {
    method new (line 9) | pub fn new(key: &[u64; 2]) -> TeaContext {
    method encrypt_block (line 16) | pub fn encrypt_block(&self, block: u64) -> u64 {
    method decrypt_block (line 31) | pub fn decrypt_block(&self, block: u64) -> u64 {
  function divide_u64 (line 48) | fn divide_u64(n: u64) -> (W<u32>, W<u32>) {
  function tea_encrypt (line 52) | pub fn tea_encrypt(plain: &[u8], key: &[u8]) -> Vec<u8> {
  function tea_decrypt (line 64) | pub fn tea_decrypt(cipher: &[u8], key: &[u8]) -> Vec<u8> {
  function to_block (line 77) | fn to_block(data: &[u8]) -> u64 {
  function from_block (line 88) | fn from_block(block: u64) -> [u8; 8] {
  function test_block_convert (line 106) | fn test_block_convert() {
  function test_tea_encrypt (line 119) | fn test_tea_encrypt() {
  function test_tea_encdec (line 133) | fn test_tea_encdec() {

FILE: src/ciphers/theoretical_rot13.rs
  function theoretical_rot13 (line 2) | pub fn theoretical_rot13(text: &str) -> String {
  function test_single_letter (line 26) | fn test_single_letter() {
  function test_bunch_of_letters (line 30) | fn test_bunch_of_letters() {
  function test_non_ascii (line 35) | fn test_non_ascii() {
  function test_twice (line 40) | fn test_twice() {

FILE: src/ciphers/transposition.rs
  function transposition (line 12) | pub fn transposition(decrypt_mode: bool, msg: &str, key: &str) -> String {
  function encrypt (line 62) | fn encrypt(mut msg: String, key_order: Vec<usize>) -> String {
  function decrypt (line 123) | fn decrypt(mut msg: String, key_order: Vec<usize>) -> String {
  function encryption (line 190) | fn encryption() {
  function decryption (line 216) | fn decryption() {
  function double_encryption (line 238) | fn double_encryption() {
  function double_decryption (line 264) | fn double_decryption() {

FILE: src/ciphers/trifid.rs
  type CharToNum (line 9) | type CharToNum = HashMap<char, String>;
  type NumToChar (line 10) | type NumToChar = HashMap<String, char>;
  type PrepareResult (line 11) | type PrepareResult = Result<(String, String, CharToNum, NumToChar), Stri...
  constant TRIGRAM_VALUES (line 13) | const TRIGRAM_VALUES: [&str; 27] = [
  function trifid_encrypt (line 26) | pub fn trifid_encrypt(message: &str, alphabet: &str, period: usize) -> R...
  function trifid_decrypt (line 57) | pub fn trifid_decrypt(message: &str, alphabet: &str, period: usize) -> R...
  function encrypt_part (line 90) | fn encrypt_part(message_part: &str, char_to_num: &CharToNum) -> String {
  function decrypt_part (line 109) | fn decrypt_part(message_part: &str, char_to_num: &CharToNum) -> (String,...
  function prepare (line 141) | fn prepare(message: &str, alphabet: &str) -> PrepareResult {
  constant DEFAULT_ALPHABET (line 177) | const DEFAULT_ALPHABET: &str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.";
  function test_encrypt_basic (line 180) | fn test_encrypt_basic() {
  function test_encrypt_empty (line 186) | fn test_encrypt_empty() {
  function test_encrypt_custom_alphabet (line 192) | fn test_encrypt_custom_alphabet() {
  function test_decrypt_basic (line 202) | fn test_decrypt_basic() {
  function test_decrypt_custom_alphabet (line 208) | fn test_decrypt_custom_alphabet() {
  function test_encrypt_decrypt_roundtrip (line 214) | fn test_encrypt_decrypt_roundtrip() {
  function test_invalid_alphabet_length (line 223) | fn test_invalid_alphabet_length() {
  function test_invalid_character_in_message (line 230) | fn test_invalid_character_in_message() {
  function test_encrypt_part (line 240) | fn test_encrypt_part() {
  function test_decrypt_part (line 251) | fn test_decrypt_part() {
  function test_decrypt_part_single_char (line 264) | fn test_decrypt_part_single_char() {
  function test_decrypt_part_empty (line 275) | fn test_decrypt_part_empty() {
  function test_decrypt_part_with_unmapped_chars (line 284) | fn test_decrypt_part_with_unmapped_chars() {

FILE: src/ciphers/vernam.rs
  function vernam_encrypt (line 40) | pub fn vernam_encrypt(plaintext: &str, key: &str) -> String {
  function vernam_decrypt (line 100) | pub fn vernam_decrypt(ciphertext: &str, key: &str) -> String {
  function test_encrypt_basic (line 140) | fn test_encrypt_basic() {
  function test_decrypt_basic (line 145) | fn test_decrypt_basic() {
  function test_encrypt_decrypt_roundtrip (line 150) | fn test_encrypt_decrypt_roundtrip() {
  function test_encrypt_decrypt_long_text (line 159) | fn test_encrypt_decrypt_long_text() {
  function test_lowercase_input (line 168) | fn test_lowercase_input() {
  function test_mixed_case_input (line 175) | fn test_mixed_case_input() {
  function test_single_character (line 181) | fn test_single_character() {
  function test_key_wrapping (line 187) | fn test_key_wrapping() {
  function test_alphabet_boundary (line 196) | fn test_alphabet_boundary() {
  function test_same_key_as_plaintext (line 203) | fn test_same_key_as_plaintext() {
  function test_with_spaces_and_numbers (line 210) | fn test_with_spaces_and_numbers() {
  function test_empty_key_encrypt (line 219) | fn test_empty_key_encrypt() {
  function test_empty_key_decrypt (line 225) | fn test_empty_key_decrypt() {
  function test_key_with_only_numbers (line 231) | fn test_key_with_only_numbers() {
  function test_empty_plaintext (line 236) | fn test_empty_plaintext() {
  function test_plaintext_with_only_numbers (line 241) | fn test_plaintext_with_only_numbers() {

FILE: src/ciphers/vigenere.rs
  function vigenere (line 10) | pub fn vigenere(plain_text: &str, key: &str) -> String {
  function empty (line 43) | fn empty() {
  function vigenere_base (line 48) | fn vigenere_base() {
  function vigenere_with_spaces (line 56) | fn vigenere_with_spaces() {
  function vigenere_unicode_and_numbers (line 67) | fn vigenere_unicode_and_numbers() {
  function vigenere_unicode_key (line 75) | fn vigenere_unicode_key() {
  function vigenere_empty_key (line 83) | fn vigenere_empty_key() {

FILE: src/ciphers/xor.rs
  function xor_bytes (line 1) | pub fn xor_bytes(text: &[u8], key: u8) -> Vec<u8> {
  function xor (line 5) | pub fn xor(text: &str, key: u8) -> Vec<u8> {
  function test_simple (line 14) | fn test_simple() {
  function test_every_alphabet_with_space (line 21) | fn test_every_alphabet_with_space() {
  function test_multi_byte (line 28) | fn test_multi_byte() {
  function test_zero_byte (line 36) | fn test_zero_byte() {
  function test_invalid_byte (line 44) | fn test_invalid_byte() {

FILE: src/compression/burrows_wheeler_transform.rs
  type BwtResult (line 17) | pub struct BwtResult {
  function all_rotations (line 43) | pub fn all_rotations(s: &str) -> Vec<String> {
  function bwt_transform (line 75) | pub fn bwt_transform(s: &str) -> BwtResult {
  function reverse_bwt (line 123) | pub fn reverse_bwt(bwt_string: &str, idx_original_string: usize) -> Stri...
  function test_all_rotations_banana (line 150) | fn test_all_rotations_banana() {
  function test_all_rotations_casa (line 163) | fn test_all_rotations_casa() {
  function test_all_rotations_panama (line 172) | fn test_all_rotations_panama() {
  function test_bwt_transform_banana (line 180) | fn test_bwt_transform_banana() {
  function test_bwt_transform_casa (line 187) | fn test_bwt_transform_casa() {
  function test_bwt_transform_panama (line 194) | fn test_bwt_transform_panama() {
  function test_bwt_transform_empty (line 202) | fn test_bwt_transform_empty() {
  function test_reverse_bwt_banana (line 207) | fn test_reverse_bwt_banana() {
  function test_reverse_bwt_casa (line 213) | fn test_reverse_bwt_casa() {
  function test_reverse_bwt_panama (line 219) | fn test_reverse_bwt_panama() {
  function test_reverse_bwt_empty_string (line 226) | fn test_reverse_bwt_empty_string() {
  function test_reverse_bwt_index_too_high (line 232) | fn test_reverse_bwt_index_too_high() {
  function test_bwt_roundtrip (line 237) | fn test_bwt_roundtrip() {
  function test_single_character (line 255) | fn test_single_character() {
  function test_repeated_characters (line 265) | fn test_repeated_characters() {

FILE: src/compression/huffman_encoding.rs
  type HuffmanNode (line 51) | enum HuffmanNode {
    method frequency (line 64) | fn frequency(&self) -> usize {
    method new_leaf (line 73) | fn new_leaf(character: char, frequency: usize) -> Self {
    method new_internal (line 81) | fn new_internal(left: HuffmanNode, right: HuffmanNode) -> Self {
  type HeapNode (line 93) | struct HeapNode(HuffmanNode);
  method cmp (line 96) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 103) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  function build_frequency_map (line 117) | fn build_frequency_map(text: &str) -> HashMap<char, usize> {
  function build_huffman_tree (line 134) | fn build_huffman_tree(frequencies: HashMap<char, usize>) -> Option<Huffm...
  function generate_codes (line 167) | fn generate_codes(node: &HuffmanNode, code: String, codes: &mut HashMap<...
  function huffman_encode (line 208) | pub fn huffman_encode(text: &str) -> (String, HashMap<char, String>) {
  function huffman_decode (line 245) | pub fn huffman_decode(encoded: &str, codes: &HashMap<char, String>) -> S...
  function demonstrate_huffman_from_file (line 303) | pub fn demonstrate_huffman_from_file(file_path: &str) -> std::io::Result...
  function test_empty_string (line 398) | fn test_empty_string() {
  function test_single_character (line 405) | fn test_single_character() {
  function test_simple_string (line 412) | fn test_simple_string() {
  function test_encode_decode_roundtrip (line 427) | fn test_encode_decode_roundtrip() {
  function test_frequency_based_encoding (line 444) | fn test_frequency_based_encoding() {
  function test_compression_ratio (line 457) | fn test_compression_ratio() {
  function test_all_unique_characters (line 468) | fn test_all_unique_characters() {
  function test_build_frequency_map (line 481) | fn test_build_frequency_map() {
  function test_unicode_characters (line 490) | fn test_unicode_characters() {
  function test_demonstrate_huffman_from_file (line 498) | fn test_demonstrate_huffman_from_file() {
  function test_demonstrate_empty_file (line 517) | fn test_demonstrate_empty_file() {
  function main (line 539) | fn main() {

FILE: src/compression/lz77.rs
  type Token (line 43) | pub struct Token {
    method new (line 51) | pub fn new(offset: usize, length: usize, indicator: char) -> Self {
    method fmt (line 61) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type LZ77Compressor (line 68) | pub struct LZ77Compressor {
    method new (line 91) | pub fn new(window_size: usize, lookahead_buffer_size: usize) -> Self {
    method compress (line 121) | pub fn compress(&self, text: &str) -> Vec<Token> {
    method decompress (line 177) | pub fn decompress(&self, tokens: &[Token]) -> String {
    method find_encoding_token (line 198) | fn find_encoding_token(&self, text: &str, search_buffer: &str) -> Token {
    method match_length_from_index (line 241) | fn match_length_from_index(
  method default (line 266) | fn default() -> Self {
  function test_token_display (line 276) | fn test_token_display() {
  function test_compress_ababcbababaa (line 282) | fn test_compress_ababcbababaa() {
  function test_compress_aacaacabcabaaac (line 298) | fn test_compress_aacaacabcabaaac() {
  function test_decompress_cabracadabrarrarrad (line 314) | fn test_decompress_cabracadabrarrarrad() {
  function test_decompress_ababcbababaa (line 332) | fn test_decompress_ababcbababaa() {
  function test_decompress_aacaacabcabaaac (line 347) | fn test_decompress_aacaacabcabaaac() {
  function test_round_trip_compression (line 362) | fn test_round_trip_compression() {
  function test_empty_search_buffer (line 381) | fn test_empty_search_buffer() {
  function test_empty_text_panics (line 389) | fn test_empty_text_panics() {
  function test_default_compressor (line 395) | fn test_default_compressor() {
  function test_invalid_buffer_sizes (line 405) | fn test_invalid_buffer_sizes() {
  function test_single_character (line 410) | fn test_single_character() {
  function test_repeated_pattern (line 419) | fn test_repeated_pattern() {

FILE: src/compression/move_to_front.rs
  function blank_char_table (line 3) | fn blank_char_table() -> Vec<char> {
  function move_to_front_encode (line 7) | pub fn move_to_front_encode(text: &str) -> Vec<u8> {
  function move_to_front_decode (line 22) | pub fn move_to_front_decode(encoded: &[u8]) -> String {

FILE: src/compression/run_length_encoding.rs
  function run_length_encode (line 3) | pub fn run_length_encode(text: &str) -> Vec<(char, i32)> {
  function run_length_decode (line 19) | pub fn run_length_decode(encoded: &[(char, i32)]) -> String {
  function test_run_length_decode (line 33) | fn test_run_length_decode() {
  function test_run_length_encode (line 43) | fn test_run_length_encode() {

FILE: src/conversions/binary_to_decimal.rs
  function binary_to_decimal (line 3) | pub fn binary_to_decimal(binary: &str) -> Option<u128> {
  function basic_binary_to_decimal (line 31) | fn basic_binary_to_decimal() {
  function big_binary_to_decimal (line 37) | fn big_binary_to_decimal() {
  function very_big_binary_to_decimal (line 54) | fn very_big_binary_to_decimal() {

FILE: src/conversions/binary_to_hexadecimal.rs
  function binary_to_hexadecimal (line 25) | pub fn binary_to_hexadecimal(binary_str: &str) -> String {
  function test_empty_string (line 80) | fn test_empty_string() {
  function test_invalid_binary (line 87) | fn test_invalid_binary() {
  function test_binary (line 94) | fn test_binary() {
  function test_padded_binary (line 101) | fn test_padded_binary() {

FILE: src/conversions/binary_to_octal.rs
  function binary_to_octal (line 7) | pub fn binary_to_octal(binary_str: &str) -> Result<String, &'static str> {
  function test_binary_to_octal (line 38) | fn test_binary_to_octal() {
  function test_invalid_input (line 46) | fn test_invalid_input() {

FILE: src/conversions/decimal_to_binary.rs
  function decimal_to_binary (line 1) | pub fn decimal_to_binary(base_num: u64) -> String {
  function converting_decimal_to_binary (line 22) | fn converting_decimal_to_binary() {

FILE: src/conversions/decimal_to_hexadecimal.rs
  function decimal_to_hexadecimal (line 1) | pub fn decimal_to_hexadecimal(base_num: u64) -> String {
  function test_zero (line 28) | fn test_zero() {
  function test_single_digit_decimal (line 33) | fn test_single_digit_decimal() {
  function test_single_digit_hexadecimal (line 38) | fn test_single_digit_hexadecimal() {
  function test_multiple_digit_hexadecimal (line 43) | fn test_multiple_digit_hexadecimal() {
  function test_big (line 48) | fn test_big() {
  function test_random (line 53) | fn test_random() {

FILE: src/conversions/decimal_to_octal.rs
  function decimal_to_octal (line 7) | pub fn decimal_to_octal(decimal_num: u64) -> String {
  function test_decimal_to_octal (line 30) | fn test_decimal_to_octal() {

FILE: src/conversions/energy.rs
  type EnergyUnit (line 13) | pub enum EnergyUnit {
    method to_joule (line 95) | fn to_joule(self, value: f64) -> f64 {
    method joule_to_unit (line 168) | fn joule_to_unit(self, joule: f64) -> f64 {
  function convert_energy (line 242) | pub fn convert_energy(value: f64, from: EnergyUnit, to: EnergyUnit) -> f...
  constant EPSILON (line 251) | const EPSILON: f64 = 1e-10;
  function approx_eq (line 253) | fn approx_eq(a: f64, b: f64) -> bool {
  function test_same_unit_conversion (line 258) | fn test_same_unit_conversion() {
  function test_joule_to_kilojoule (line 273) | fn test_joule_to_kilojoule() {
  function test_joule_to_megajoule (line 285) | fn test_joule_to_megajoule() {
  function test_joule_to_gigajoule (line 297) | fn test_joule_to_gigajoule() {
  function test_watt_second (line 305) | fn test_watt_second() {
  function test_watt_hour (line 313) | fn test_watt_hour() {
  function test_kilowatt_hour_conversions (line 319) | fn test_kilowatt_hour_conversions() {
  function test_newton_meter (line 331) | fn test_newton_meter() {
  function test_calorie_nutritional (line 339) | fn test_calorie_nutritional() {
  function test_electronvolt (line 354) | fn test_electronvolt() {
  function test_btu_conversions (line 360) | fn test_btu_conversions() {
  function test_foot_pound (line 369) | fn test_foot_pound() {
  function test_round_trip_conversions (line 375) | fn test_round_trip_conversions() {
  function test_megawatt_hour (line 401) | fn test_megawatt_hour() {
  function test_horsepower_hour (line 409) | fn test_horsepower_hour() {
  function test_therm (line 415) | fn test_therm() {
  function test_ton_explosives (line 423) | fn test_ton_explosives() {
  function test_kiloton (line 431) | fn test_kiloton() {
  function test_erg (line 439) | fn test_erg() {
  function test_small_si_units (line 451) | fn test_small_si_units() {
  function test_calorie_variants (line 467) | fn test_calorie_variants() {
  function test_food_energy (line 475) | fn test_food_energy() {
  function test_electricity_bill (line 486) | fn test_electricity_bill() {
  function test_zero_value (line 493) | fn test_zero_value() {
  function test_negative_value (line 501) | fn test_negative_value() {
  function test_large_value (line 509) | fn test_large_value() {
  function test_imperial_units (line 515) | fn test_imperial_units() {
  function test_electron_volt_variants (line 524) | fn test_electron_volt_variants() {
  function test_therm_variants (line 540) | fn test_therm_variants() {
  function test_explosive_yield (line 553) | fn test_explosive_yield() {
  function test_atomic_units (line 560) | fn test_atomic_units() {

FILE: src/conversions/hexadecimal_to_binary.rs
  function hexadecimal_to_binary (line 7) | pub fn hexadecimal_to_binary(hex_str: &str) -> Result<String, String> {
  function test_empty_string (line 42) | fn test_empty_string() {
  function test_hexadecimal (line 49) | fn test_hexadecimal() {
  function test_hexadecimal2 (line 55) | fn test_hexadecimal2() {
  function test_invalid_hexadecimal (line 62) | fn test_invalid_hexadecimal() {

FILE: src/conversions/hexadecimal_to_decimal.rs
  function hexadecimal_to_decimal (line 1) | pub fn hexadecimal_to_decimal(hexadecimal_str: &str) -> Result<u64, &'st...
  function test_hexadecimal_to_decimal_empty (line 23) | fn test_hexadecimal_to_decimal_empty() {
  function test_hexadecimal_to_decimal_invalid (line 28) | fn test_hexadecimal_to_decimal_invalid() {
  function test_hexadecimal_to_decimal_valid1 (line 40) | fn test_hexadecimal_to_decimal_valid1() {
  function test_hexadecimal_to_decimal_valid2 (line 48) | fn test_hexadecimal_to_decimal_valid2() {
  function test_hexadecimal_to_decimal_valid3 (line 56) | fn test_hexadecimal_to_decimal_valid3() {

FILE: src/conversions/hexadecimal_to_octal.rs
  function hexadecimal_to_octal (line 7) | pub fn hexadecimal_to_octal(hex_str: &str) -> Result<String, &'static st...
  function test_hexadecimal_to_octal (line 45) | fn test_hexadecimal_to_octal() {
  function test_invalid_input (line 53) | fn test_invalid_input() {

FILE: src/conversions/ipv4_conversion.rs
  type Ipv4Error (line 11) | pub enum Ipv4Error {
    method fmt (line 23) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method from (line 36) | fn from(_: ParseIntError) -> Self {
  function ipv4_to_decimal (line 54) | pub fn ipv4_to_decimal(ipv4_address: &str) -> Result<u32, Ipv4Error> {
  function alt_ipv4_to_decimal (line 90) | pub fn alt_ipv4_to_decimal(ipv4_address: &str) -> Result<u32, Ipv4Error> {
  function decimal_to_ipv4 (line 123) | pub fn decimal_to_ipv4(decimal_ipv4: u32) -> Result<String, Ipv4Error> {
  function test_ipv4_to_decimal_valid (line 141) | fn test_ipv4_to_decimal_valid() {
  function test_ipv4_to_decimal_invalid_format (line 150) | fn test_ipv4_to_decimal_invalid_format() {
  function test_ipv4_to_decimal_invalid_octet (line 158) | fn test_ipv4_to_decimal_invalid_octet() {
  function test_ipv4_to_decimal_parse_error (line 174) | fn test_ipv4_to_decimal_parse_error() {
  function test_alt_ipv4_to_decimal_valid (line 180) | fn test_alt_ipv4_to_decimal_valid() {
  function test_alt_ipv4_to_decimal_invalid (line 188) | fn test_alt_ipv4_to_decimal_invalid() {
  function test_decimal_to_ipv4_valid (line 200) | fn test_decimal_to_ipv4_valid() {
  function test_round_trip_conversion (line 210) | fn test_round_trip_conversion() {
  function test_both_methods_agree (line 230) | fn test_both_methods_agree() {
  function test_edge_cases (line 248) | fn test_edge_cases() {

FILE: src/conversions/length_conversion.rs
  type LengthUnit (line 15) | pub enum LengthUnit {
  function unit_to_meter_multiplier (line 26) | fn unit_to_meter_multiplier(from: LengthUnit) -> f64 {
  function unit_to_meter (line 39) | fn unit_to_meter(input: f64, from: LengthUnit) -> f64 {
  function meter_to_unit (line 43) | fn meter_to_unit(input: f64, to: LengthUnit) -> f64 {
  function length_conversion (line 49) | pub fn length_conversion(input: f64, from: LengthUnit, to: LengthUnit) -...
  function zero_to_zero (line 61) | fn zero_to_zero() {
  function length_of_one_meter (line 74) | fn length_of_one_meter() {

FILE: src/conversions/octal_to_binary.rs
  function octal_to_binary (line 6) | pub fn octal_to_binary(octal_str: &str) -> Result<String, &'static str> {
  function test_empty_string (line 41) | fn test_empty_string() {
  function test_invalid_octal (line 48) | fn test_invalid_octal() {
  function test_valid_octal (line 55) | fn test_valid_octal() {

FILE: src/conversions/octal_to_decimal.rs
  function octal_to_decimal (line 7) | pub fn octal_to_decimal(octal_str: &str) -> Result<u64, &'static str> {
  function test_empty_string (line 27) | fn test_empty_string() {
  function test_invalid_octal (line 34) | fn test_invalid_octal() {
  function test_valid_octal (line 41) | fn test_valid_octal() {
  function test_valid_octal2 (line 48) | fn test_valid_octal2() {
  function test_valid_octal3 (line 55) | fn test_valid_octal3() {

FILE: src/conversions/octal_to_hexadecimal.rs
  function octal_to_hexadecimal (line 7) | pub fn octal_to_hexadecimal(octal_str: &str) -> Result<String, &'static ...
  function test_octal_to_hexadecimal (line 36) | fn test_octal_to_hexadecimal() {
  function test_invalid_input (line 44) | fn test_invalid_input() {

FILE: src/conversions/order_of_magnitude_conversion.rs
  type MetricLengthUnit (line 43) | pub enum MetricLengthUnit {
    method exponent (line 76) | pub fn exponent(&self) -> i32 {
    method symbol (line 100) | pub fn symbol(&self) -> &'static str {
    method fmt (line 163) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 116) | type Err = String;
  method from_str (line 141) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function convert_metric_length (line 191) | pub fn convert_metric_length(value: f64, from: MetricLengthUnit, to: Met...
  function metric_length_conversion (line 232) | pub fn metric_length_conversion(value: f64, from_type: &str, to_type: &s...
  function test_unit_exponents (line 253) | fn test_unit_exponents() {
  function test_unit_symbols (line 266) | fn test_unit_symbols() {
  function test_from_str_full_names (line 279) | fn test_from_str_full_names() {
  function test_from_str_symbols (line 295) | fn test_from_str_symbols() {
  function test_from_str_case_insensitive (line 315) | fn test_from_str_case_insensitive() {
  function test_from_str_plurals (line 331) | fn test_from_str_plurals() {
  function test_from_str_british_spellings (line 343) | fn test_from_str_british_spellings() {
  function test_from_str_american_and_british_equivalent (line 394) | fn test_from_str_american_and_british_equivalent() {
  function test_from_str_invalid (line 403) | fn test_from_str_invalid() {
  function test_convert_length_meter_to_kilometer (line 410) | fn test_convert_length_meter_to_kilometer() {
  function test_convert_length_meter_to_megameter (line 417) | fn test_convert_length_meter_to_megameter() {
  function test_convert_length_gigameter_to_meter (line 424) | fn test_convert_length_gigameter_to_meter() {
  function test_convert_length_gigameter_to_terameter (line 431) | fn test_convert_length_gigameter_to_terameter() {
  function test_convert_length_petameter_to_terameter (line 441) | fn test_convert_length_petameter_to_terameter() {
  function test_convert_length_petameter_to_exameter (line 451) | fn test_convert_length_petameter_to_exameter() {
  function test_convert_length_terameter_to_zettameter (line 458) | fn test_convert_length_terameter_to_zettameter() {
  function test_convert_length_yottameter_to_zettameter (line 468) | fn test_convert_length_yottameter_to_zettameter() {
  function test_convert_length_same_unit (line 478) | fn test_convert_length_same_unit() {
  function test_length_conversion_str_basic (line 488) | fn test_length_conversion_str_basic() {
  function test_length_conversion_str_symbols (line 494) | fn test_length_conversion_str_symbols() {
  function test_length_conversion_str_case_insensitive (line 500) | fn test_length_conversion_str_case_insensitive() {
  function test_length_conversion_str_plurals (line 506) | fn test_length_conversion_str_plurals() {
  function test_length_conversion_str_british_spellings (line 512) | fn test_length_conversion_str_british_spellings() {
  function test_length_conversion_str_invalid_from (line 532) | fn test_length_conversion_str_invalid_from() {
  function test_length_conversion_str_invalid_to (line 539) | fn test_length_conversion_str_invalid_to() {
  function test_length_conversion_str_large_values (line 546) | fn test_length_conversion_str_large_values() {
  function test_length_conversion_str_small_values (line 552) | fn test_length_conversion_str_small_values() {
  function test_all_conversions_reversible (line 558) | fn test_all_conversions_reversible() {

FILE: src/conversions/pressure.rs
  type IntoPressureUnit (line 15) | pub trait IntoPressureUnit {
    method into_pressure_unit (line 16) | fn into_pressure_unit(self) -> Result<PressureUnit, String>;
    method into_pressure_unit (line 20) | fn into_pressure_unit(self) -> Result<PressureUnit, String> {
    method into_pressure_unit (line 26) | fn into_pressure_unit(self) -> Result<PressureUnit, String> {
    method into_pressure_unit (line 32) | fn into_pressure_unit(self) -> Result<PressureUnit, String> {
  type PressureUnit (line 39) | pub enum PressureUnit {
    method fmt (line 81) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method to_pascal_factor (line 115) | fn to_pascal_factor(self) -> f64 {
    method supported_units (line 155) | pub fn supported_units() -> Vec<&'static str> {
  type Err (line 165) | type Err = String;
  method from_str (line 167) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function convert_pressure (line 225) | pub fn convert_pressure<F, T>(value: f64, from_unit: F, to_unit: T) -> R...
  constant EPSILON (line 253) | const EPSILON: f64 = 1e-3;
  function approx_eq (line 255) | fn approx_eq(a: f64, b: f64) -> bool {
  function test_pressure_conversions (line 260) | fn test_pressure_conversions() {
  function test_additional_coverage (line 392) | fn test_additional_coverage() {

FILE: src/conversions/rectangular_to_polar.rs
  function rectangular_to_polar (line 19) | pub fn rectangular_to_polar(real: f64, imag: f64) -> (f64, f64) {
  function round_to_two_decimals (line 29) | fn round_to_two_decimals(value: f64) -> f64 {
  function test_rectangular_to_polar (line 38) | fn test_rectangular_to_polar() {

FILE: src/conversions/rgb_cmyk_conversion.rs
  function rgb_to_cmyk (line 15) | pub fn rgb_to_cmyk(rgb: (u8, u8, u8)) -> (u8, u8, u8, u8) {

FILE: src/conversions/rgb_hsv_conversion.rs
  type ColorError (line 17) | pub enum ColorError {
    method fmt (line 27) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Rgb (line 44) | pub struct Rgb {
    method new (line 52) | pub fn new(red: u8, green: u8, blue: u8) -> Self {
  type Hsv (line 59) | pub struct Hsv {
    method new (line 67) | pub fn new(hue: f64, saturation: f64, value: f64) -> Result<Self, Colo...
    method approximately_equal (line 90) | pub fn approximately_equal(&self, other: &Hsv) -> bool {
  function hsv_to_rgb (line 113) | pub fn hsv_to_rgb(hue: f64, saturation: f64, value: f64) -> Result<Rgb, ...
  function rgb_to_hsv (line 187) | pub fn rgb_to_hsv(red: u8, green: u8, blue: u8) -> Result<Hsv, ColorErro...
  function test_hsv_to_rgb_basic_colors (line 222) | fn test_hsv_to_rgb_basic_colors() {
  function test_hsv_to_rgb_intermediate_colors (line 246) | fn test_hsv_to_rgb_intermediate_colors() {
  function test_hsv_to_rgb_invalid_hue (line 256) | fn test_hsv_to_rgb_invalid_hue() {
  function test_hsv_to_rgb_invalid_saturation (line 268) | fn test_hsv_to_rgb_invalid_saturation() {
  function test_hsv_to_rgb_invalid_value (line 280) | fn test_hsv_to_rgb_invalid_value() {
  function test_rgb_to_hsv_basic_colors (line 292) | fn test_rgb_to_hsv_basic_colors() {
  function test_rgb_to_hsv_intermediate_colors (line 323) | fn test_rgb_to_hsv_intermediate_colors() {
  function test_round_trip_conversion (line 339) | fn test_round_trip_conversion() {
  function test_approximately_equal_hsv (line 365) | fn test_approximately_equal_hsv() {
  function test_hsv_new_validation (line 384) | fn test_hsv_new_validation() {
  function test_edge_cases (line 411) | fn test_edge_cases() {
  function test_rgb_struct (line 427) | fn test_rgb_struct() {

FILE: src/conversions/roman_numerals.rs
  constant ROMAN_NUMERALS (line 23) | const ROMAN_NUMERALS: [(u32, &str); 13] = [
  function roman_to_int (line 68) | pub fn roman_to_int(roman: &str) -> Result<u32, String> {
  function int_to_roman (line 146) | pub fn int_to_roman(mut number: u32) -> Result<String, String> {
  function char_to_value (line 183) | fn char_to_value(ch: char) -> u32 {
  function test_roman_to_int_basic (line 201) | fn test_roman_to_int_basic() {
  function test_roman_to_int_additive (line 212) | fn test_roman_to_int_additive() {
  function test_roman_to_int_subtractive (line 225) | fn test_roman_to_int_subtractive() {
  function test_roman_to_int_complex (line 235) | fn test_roman_to_int_complex() {
  function test_roman_to_int_case_insensitive (line 245) | fn test_roman_to_int_case_insensitive() {
  function test_roman_to_int_invalid_character (line 252) | fn test_roman_to_int_invalid_character() {
  function test_roman_to_int_empty (line 260) | fn test_roman_to_int_empty() {
  function test_int_to_roman_basic (line 265) | fn test_int_to_roman_basic() {
  function test_int_to_roman_additive (line 276) | fn test_int_to_roman_additive() {
  function test_int_to_roman_subtractive (line 289) | fn test_int_to_roman_subtractive() {
  function test_int_to_roman_complex (line 299) | fn test_int_to_roman_complex() {
  function test_int_to_roman_out_of_range (line 309) | fn test_int_to_roman_out_of_range() {
  function test_roundtrip_conversion (line 316) | fn test_roundtrip_conversion() {
  function test_all_examples_from_python (line 326) | fn test_all_examples_from_python() {
  function test_edge_cases (line 343) | fn test_edge_cases() {

FILE: src/conversions/speed.rs
  type SpeedUnit (line 16) | pub enum SpeedUnit {
    method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method as_kmh_multiplier (line 49) | fn as_kmh_multiplier(self) -> f64 {
    method kmh_multiplier (line 62) | fn kmh_multiplier(self) -> f64 {
  function convert_speed (line 86) | pub fn convert_speed(speed: f64, from: SpeedUnit, to: SpeedUnit) -> f64 {
  function test_speed_conversion (line 97) | fn test_speed_conversion() {
  function test_display (line 221) | fn test_display() {

FILE: src/conversions/temperature.rs
  type TemperatureUnit (line 14) | pub enum TemperatureUnit {
    method to_kelvin (line 26) | fn to_kelvin(self, value: f64) -> f64 {
    method kelvin_to_unit (line 39) | fn kelvin_to_unit(self, kelvin: f64) -> f64 {
  function convert_temperature (line 53) | pub fn convert_temperature(value: f64, from: TemperatureUnit, to: Temper...
  constant EPSILON (line 62) | const EPSILON: f64 = 1e-10;
  function approx_eq (line 64) | fn approx_eq(a: f64, b: f64) -> bool {
  function test_celsius_conversions (line 69) | fn test_celsius_conversions() {
  function test_fahrenheit_conversions (line 105) | fn test_fahrenheit_conversions() {
  function test_kelvin_conversions (line 125) | fn test_kelvin_conversions() {
  function test_round_trip_conversions (line 141) | fn test_round_trip_conversions() {
  function test_special_temperatures (line 167) | fn test_special_temperatures() {
  function test_historical_scales (line 206) | fn test_historical_scales() {
  function test_same_unit_conversion (line 239) | fn test_same_unit_conversion() {

FILE: src/conversions/time.rs
  type TimeUnit (line 12) | pub enum TimeUnit {
    method to_seconds (line 24) | fn to_seconds(self) -> f64 {
    method from_str (line 37) | fn from_str(s: &str) -> Result<Self, String> {
  function convert_time (line 70) | pub fn convert_time(time_value: f64, unit_from: &str, unit_to: &str) -> ...
  function test_seconds_to_hours (line 93) | fn test_seconds_to_hours() {
  function test_case_insensitive (line 98) | fn test_case_insensitive() {
  function test_weeks_to_days (line 105) | fn test_weeks_to_days() {
  function test_hours_to_minutes (line 110) | fn test_hours_to_minutes() {
  function test_days_to_months (line 115) | fn test_days_to_months() {
  function test_months_to_years (line 120) | fn test_months_to_years() {
  function test_years_to_seconds (line 125) | fn test_years_to_seconds() {
  function test_negative_value (line 130) | fn test_negative_value() {
  function test_invalid_from_unit (line 140) | fn test_invalid_from_unit() {
  function test_invalid_to_unit (line 147) | fn test_invalid_to_unit() {
  function test_zero_value (line 154) | fn test_zero_value() {
  function test_same_unit (line 159) | fn test_same_unit() {

FILE: src/conversions/volume.rs
  type VolumeUnit (line 11) | pub enum VolumeUnit {
    method to_cubic_meters (line 64) | fn to_cubic_meters(self, value: f64) -> f64 {
    method cubic_meters_to_unit (line 118) | fn cubic_meters_to_unit(self, cubic_meters: f64) -> f64 {
  function convert_volume (line 185) | pub fn convert_volume(value: f64, from: VolumeUnit, to: VolumeUnit) -> f...
  constant EPSILON (line 194) | const EPSILON: f64 = 1e-9;
  function approx_eq (line 196) | fn approx_eq(a: f64, b: f64, tolerance: f64) -> bool {
  function test_volume_conversions (line 201) | fn test_volume_conversions() {
  function test_round_trip_conversions (line 465) | fn test_round_trip_conversions() {
  function test_same_unit_conversion (line 491) | fn test_same_unit_conversion() {

FILE: src/conversions/weight.rs
  type IntoWeightUnit (line 40) | pub trait IntoWeightUnit {
    method into_weight_unit (line 41) | fn into_weight_unit(self) -> Result<WeightUnit, String>;
    method into_weight_unit (line 45) | fn into_weight_unit(self) -> Result<WeightUnit, String> {
    method into_weight_unit (line 51) | fn into_weight_unit(self) -> Result<WeightUnit, String> {
    method into_weight_unit (line 57) | fn into_weight_unit(self) -> Result<WeightUnit, String> {
  type WeightUnit (line 64) | pub enum WeightUnit {
    method fmt (line 102) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method to_kilogram_factor (line 145) | fn to_kilogram_factor(self) -> f64 {
    method supported_units (line 186) | pub fn supported_units() -> Vec<&'static str> {
  type Err (line 216) | type Err = String;
  method from_str (line 218) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function convert_weight (line 287) | pub fn convert_weight<F, T>(value: f64, from_unit: F, to_unit: T) -> Res...
  constant EPSILON (line 315) | const EPSILON: f64 = 1e-6;
  function approx_eq (line 317) | fn approx_eq(a: f64, b: f64) -> bool {
  function test_kilogram_conversions (line 329) | fn test_kilogram_conversions() {
  function test_large_metric_conversions (line 378) | fn test_large_metric_conversions() {
  function test_gram_conversions (line 413) | fn test_gram_conversions() {
  function test_milligram_conversions (line 435) | fn test_milligram_conversions() {
  function test_small_metric_conversions (line 456) | fn test_small_metric_conversions() {
  function test_metric_ton_conversions (line 501) | fn test_metric_ton_conversions() {
  function test_long_ton_conversions (line 526) | fn test_long_ton_conversions() {
  function test_imperial_large_units (line 551) | fn test_imperial_large_units() {
  function test_short_ton_conversions (line 590) | fn test_short_ton_conversions() {
  function test_pound_conversions (line 615) | fn test_pound_conversions() {
  function test_stone_conversions (line 644) | fn test_stone_conversions() {
  function test_ounce_conversions (line 665) | fn test_ounce_conversions() {
  function test_small_imperial_units (line 690) | fn test_small_imperial_units() {
  function test_carat_conversions (line 725) | fn test_carat_conversions() {
  function test_troy_weight_system (line 746) | fn test_troy_weight_system() {
  function test_atomic_mass_unit_conversions (line 807) | fn test_atomic_mass_unit_conversions() {
  function test_using_enums (line 820) | fn test_using_enums() {
  function test_mixed_usage (line 833) | fn test_mixed_usage() {
  function test_invalid_units (line 846) | fn test_invalid_units() {
  function test_roundtrip_conversion (line 853) | fn test_roundtrip_conversion() {
  function test_string_ownership (line 862) | fn test_string_ownership() {
  function test_display_implementation (line 875) | fn test_display_implementation() {
  function test_alternative_names (line 903) | fn test_alternative_names() {

FILE: src/data_structures/avl_tree.rs
  type AVLNode (line 9) | struct AVLNode<T: Ord> {
  type AVLTree (line 21) | pub struct AVLTree<T: Ord> {
  type Side (line 28) | enum Side {
  function new (line 35) | pub fn new() -> AVLTree<T> {
  function contains (line 43) | pub fn contains(&self, value: &T) -> bool {
  function insert (line 58) | pub fn insert(&mut self, value: T) -> bool {
  function remove (line 69) | pub fn remove(&mut self, value: &T) -> bool {
  function len (line 78) | pub fn len(&self) -> usize {
  function is_empty (line 83) | pub fn is_empty(&self) -> bool {
  function node_iter (line 88) | fn node_iter(&self) -> NodeIter<'_, T> {
  function iter (line 103) | pub fn iter(&self) -> Iter<'_, T> {
  function insert (line 111) | fn insert<T: Ord>(tree: &mut Option<Box<AVLNode<T>>>, value: T) -> bool {
  function remove (line 134) | fn remove<T: Ord>(tree: &mut Option<Box<AVLNode<T>>>, value: &T) -> bool {
  function merge (line 158) | fn merge<T: Ord>(left: Box<AVLNode<T>>, right: Box<AVLNode<T>>) -> Box<A...
  function take_min (line 169) | fn take_min<T: Ord>(tree: &mut Option<Box<AVLNode<T>>>) -> Option<Box<AV...
  function child (line 189) | fn child(&self, side: Side) -> &Option<Box<AVLNode<T>>> {
  function child_mut (line 197) | fn child_mut(&mut self, side: Side) -> &mut Option<Box<AVLNode<T>>> {
  function height (line 205) | fn height(&self, side: Side) -> usize {
  function balance_factor (line 210) | fn balance_factor(&self) -> i8 {
  function update_height (line 220) | fn update_height(&mut self) {
  function rotate (line 225) | fn rotate(&mut self, side: Side) {
  function rebalance (line 237) | fn rebalance(&mut self) {
  method default (line 255) | fn default() -> Self {
  type Output (line 261) | type Output = Side;
  method not (line 263) | fn not(self) -> Self::Output {
  function from_iter (line 272) | fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
  type NodeIter (line 284) | struct NodeIter<'a, T: Ord> {
  type Item (line 289) | type Item = &'a AVLNode<T>;
  method next (line 291) | fn next(&mut self) -> Option<Self::Item> {
  type Iter (line 309) | pub struct Iter<'a, T: Ord> {
  type Item (line 314) | type Item = &'a T;
  method next (line 316) | fn next(&mut self) -> Option<&'a T> {
  function is_balanced (line 329) | fn is_balanced<T: Ord>(tree: &AVLTree<T>) -> bool {
  function len (line 335) | fn len() {
  function contains (line 341) | fn contains() {
  function insert (line 348) | fn insert() {
  function remove (line 357) | fn remove() {
  function sorted (line 366) | fn sorted() {
  function balanced (line 372) | fn balanced() {

FILE: src/data_structures/b_tree.rs
  type Node (line 5) | struct Node<T> {
  type BTree (line 10) | pub struct BTree<T> {
  type BTreeProps (line 17) | struct BTreeProps {
    method new (line 46) | fn new(degree: usize) -> Self {
    method is_maxed_out (line 54) | fn is_maxed_out<T: Ord + Copy>(&self, node: &Node<T>) -> bool {
    method split_child (line 61) | fn split_child<T: Ord + Copy + Default>(&self, parent: &mut Node<T>, c...
    method insert_non_full (line 82) | fn insert_non_full<T: Ord + Copy + Default>(&mut self, node: &mut Node...
    method traverse_node (line 103) | fn traverse_node<T: Ord + Debug>(node: &Node<T>, depth: usize) {
  function new (line 27) | fn new(degree: usize, _keys: Option<Vec<T>>, _children: Option<Vec<Node<...
  function is_leaf (line 40) | fn is_leaf(&self) -> bool {
  function new (line 123) | pub fn new(branch_factor: usize) -> Self {
  function insert (line 131) | pub fn insert(&mut self, key: T) {
  function traverse (line 142) | pub fn traverse(&self) {
  function search (line 147) | pub fn search(&self, key: T) -> bool {

FILE: src/data_structures/binary_search_tree.rs
  type BinarySearchTree (line 6) | pub struct BinarySearchTree<T>
  method default (line 19) | fn default() -> Self {
  function new (line 29) | pub fn new() -> BinarySearchTree<T> {
  function search (line 39) | pub fn search(&self, value: &T) -> bool {
  function iter (line 68) | pub fn iter(&self) -> impl Iterator<Item = &T> {
  function insert (line 73) | pub fn insert(&mut self, value: T) {
  function minimum (line 97) | pub fn minimum(&self) -> Option<&T> {
  function maximum (line 105) | pub fn maximum(&self) -> Option<&T> {
  function floor (line 113) | pub fn floor(&self, value: &T) -> Option<&T> {
  function ceil (line 145) | pub fn ceil(&self, value: &T) -> Option<&T> {
  type BinarySearchTreeIter (line 180) | struct BinarySearchTreeIter<'a, T>
  function new (line 191) | pub fn new(tree: &BinarySearchTree<T>) -> BinarySearchTreeIter<'_, T> {
  function stack_push_left (line 197) | fn stack_push_left(&mut self) {
  type Item (line 208) | type Item = &'a T;
  method next (line 210) | fn next(&mut self) -> Option<&'a T> {
  function prequel_memes_tree (line 228) | fn prequel_memes_tree() -> BinarySearchTree<&'static str> {
  function test_search (line 241) | fn test_search() {
  function test_maximum_and_minimum (line 256) | fn test_maximum_and_minimum() {
  function test_floor_and_ceil (line 278) | fn test_floor_and_ceil() {
  function test_iterator (line 322) | fn test_iterator() {

FILE: src/data_structures/fenwick_tree.rs
  type FenwickTree (line 8) | pub struct FenwickTree<T>
  type FenwickTreeError (line 19) | pub enum FenwickTreeError {
  function with_capacity (line 42) | pub fn with_capacity(capacity: usize) -> Self {
  function update (line 61) | pub fn update(&mut self, index: usize, value: T) -> Result<(), FenwickTr...
  function prefix_query (line 87) | pub fn prefix_query(&self, index: usize) -> Result<T, FenwickTreeError> {
  function range_query (line 115) | pub fn range_query(&self, left: usize, right: usize) -> Result<T, Fenwic...
  function point_query (line 143) | pub fn point_query(&self, index: usize) -> Result<T, FenwickTreeError> {
  function set (line 172) | pub fn set(&mut self, index: usize, value: T) -> Result<(), FenwickTreeE...
  function lowbit (line 194) | const fn lowbit(x: usize) -> usize {
  function test_fenwick_tree (line 203) | fn test_fenwick_tree() {

FILE: src/data_structures/floyds_algorithm.rs
  function detect_cycle (line 8) | pub fn detect_cycle<T>(linked_list: &LinkedList<T>) -> Option<usize> {
  function has_cycle (line 35) | pub fn has_cycle<T>(linked_list: &LinkedList<T>) -> bool {
  function test_detect_cycle_no_cycle (line 65) | fn test_detect_cycle_no_cycle() {
  function test_detect_cycle_with_cycle (line 77) | fn test_detect_cycle_with_cycle() {

FILE: src/data_structures/graph.rs
  type NodeNotInGraph (line 5) | pub struct NodeNotInGraph;
    method fmt (line 8) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type DirectedGraph (line 13) | pub struct DirectedGraph {
  type UndirectedGraph (line 31) | pub struct UndirectedGraph {
  type Graph (line 64) | pub trait Graph {
    method new (line 18) | fn new() -> DirectedGraph {
    method adjacency_table_mutable (line 23) | fn adjacency_table_mutable(&mut self) -> &mut HashMap<String, Vec<(Str...
    method adjacency_table (line 26) | fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>> {
    method new (line 36) | fn new() -> UndirectedGraph {
    method adjacency_table_mutable (line 41) | fn adjacency_table_mutable(&mut self) -> &mut HashMap<String, Vec<(Str...
    method adjacency_table (line 44) | fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>> {
    method add_edge (line 47) | fn add_edge(&mut self, edge: (&str, &str, i32)) {
    method new (line 65) | fn new() -> Self;
    method adjacency_table_mutable (line 66) | fn adjacency_table_mutable(&mut self) -> &mut HashMap<String, Vec<(Str...
    method adjacency_table (line 67) | fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>>;
    method add_node (line 69) | fn add_node(&mut self, node: &str) -> bool {
    method add_edge (line 80) | fn add_edge(&mut self, edge: (&str, &str, i32)) {
    method neighbours (line 91) | fn neighbours(&self, node: &str) -> Result<&Vec<(String, i32)>, NodeNo...
    method contains (line 98) | fn contains(&self, node: &str) -> bool {
    method nodes (line 102) | fn nodes(&self) -> HashSet<&String> {
    method edges (line 106) | fn edges(&self) -> Vec<(&String, &String, i32)> {
  function test_add_edge (line 122) | fn test_add_edge() {
  function test_neighbours (line 143) | fn test_neighbours() {
  function test_add_node (line 163) | fn test_add_node() {
  function test_add_edge (line 178) | fn test_add_edge() {
  function test_neighbours (line 196) | fn test_neighbours() {
  function test_contains (line 210) | fn test_contains() {

FILE: src/data_structures/hash_table.rs
  type HashTable (line 3) | pub struct HashTable<K, V> {
  method default (line 9) | fn default() -> Self {
  type Hashable (line 14) | pub trait Hashable {
    method hash (line 15) | fn hash(&self) -> usize;
    method hash (line 74) | fn hash(&self) -> usize {
  function new (line 19) | pub fn new() -> HashTable<K, V> {
  function insert (line 30) | pub fn insert(&mut self, key: K, value: V) {
  function search (line 39) | pub fn search(&self, key: K) -> Option<&V> {
  function resize (line 47) | fn resize(&mut self) {
  type TestKey (line 71) | struct TestKey(usize);
  function test_insert_and_search (line 80) | fn test_insert_and_search() {
  function test_resize (line 92) | fn test_resize() {
  function test_search_nonexistent (line 104) | fn test_search_nonexistent() {
  function test_multiple_inserts_and_searches (line 116) | fn test_multiple_inserts_and_searches() {
  function test_not_overwrite_existing_key (line 129) | fn test_not_overwrite_existing_key() {
  function test_empty_search (line 139) | fn test_empty_search() {

FILE: src/data_structures/heap.rs
  type Heap (line 17) | pub struct Heap<T> {
  function new (line 30) | pub fn new(comparator: fn(&T, &T) -> bool) -> Self {
  function from_vec (line 45) | pub fn from_vec(items: Vec<T>, comparator: fn(&T, &T) -> bool) -> Self {
  function build_heap (line 52) | fn build_heap(&mut self) {
  function len (line 63) | pub fn len(&self) -> usize {
  function is_empty (line 71) | pub fn is_empty(&self) -> bool {
  function add (line 79) | pub fn add(&mut self, value: T) {
  function pop (line 88) | pub fn pop(&mut self) -> Option<T> {
  function iter (line 103) | pub fn iter(&self) -> Iter<'_, T> {
  function heapify_up (line 111) | fn heapify_up(&mut self, mut idx: usize) {
  function heapify_down (line 126) | fn heapify_down(&mut self, mut idx: usize) {
  function parent_idx (line 158) | fn parent_idx(&self, idx: usize) -> Option<usize> {
  function children_present (line 173) | fn children_present(&self, idx: usize) -> bool {
  function left_child_idx (line 184) | fn left_child_idx(&self, idx: usize) -> usize {
  function right_child_idx (line 195) | fn right_child_idx(&self, idx: usize) -> usize {
  function new_min (line 208) | pub fn new_min() -> Heap<T> {
  function new_max (line 216) | pub fn new_max() -> Heap<T> {
  function from_vec_min (line 227) | pub fn from_vec_min(items: Vec<T>) -> Heap<T> {
  function from_vec_max (line 238) | pub fn from_vec_max(items: Vec<T>) -> Heap<T> {
  function test_empty_heap (line 248) | fn test_empty_heap() {
  function test_min_heap (line 254) | fn test_min_heap() {
  function test_max_heap (line 271) | fn test_max_heap() {
  function test_iter_heap (line 288) | fn test_iter_heap() {
  function test_from_vec_min (line 311) | fn test_from_vec_min() {
  function test_from_vec_max (line 323) | fn test_from_vec_max() {

FILE: src/data_structures/lazy_segment_tree.rs
  type LazySegmentTree (line 4) | pub struct LazySegmentTree<T: Debug + Default + Ord + Copy + Display + A...
  function from_vec (line 13) | pub fn from_vec(arr: &[T], merge: fn(T, T) -> T) -> Self {
  function build_recursive (line 27) | fn build_recursive(
  function query (line 44) | pub fn query(&mut self, range: Range<usize>) -> Option<T> {
  function query_recursive (line 48) | fn query_recursive(
  function update (line 74) | pub fn update(&mut self, target_range: Range<usize>, val: T) {
  function update_recursive (line 78) | fn update_recursive(
  function propagation (line 109) | fn propagation(&mut self, idx: usize, element_range: &Range<usize>, pare...
  function test_min_segments (line 133) | fn test_min_segments() {
  function test_max_segments (line 149) | fn test_max_segments() {
  function test_sum_segments (line 165) | fn test_sum_segments() {
  function test_update_segments_tiny (line 181) | fn test_update_segments_tiny() {
  function test_update_segments (line 194) | fn test_update_segments() {
  function check_overall_interval_min (line 217) | fn check_overall_interval_min(array: Vec<i32>) -> TestResult {
  function check_overall_interval_max (line 223) | fn check_overall_interval_max(array: Vec<i32>) -> TestResult {
  function check_overall_interval_sum (line 229) | fn check_overall_interval_sum(array: Vec<i32>) -> TestResult {
  function check_single_interval_min (line 235) | fn check_single_interval_min(array: Vec<i32>) -> TestResult {
  function check_single_interval_max (line 250) | fn check_single_interval_max(array: Vec<i32>) -> TestResult {
  function check_single_interval_sum (line 265) | fn check_single_interval_sum(array: Vec<i32>) -> TestResult {

FILE: src/data_structures/linked_list.rs
  type Node (line 5) | pub struct Node<T> {
  function new (line 12) | fn new(t: T) -> Node<T> {
  type LinkedList (line 21) | pub struct LinkedList<T> {
  method default (line 30) | fn default() -> Self {
  function new (line 36) | pub fn new() -> Self {
  function insert_at_head (line 45) | pub fn insert_at_head(&mut self, obj: T) {
  function insert_at_tail (line 58) | pub fn insert_at_tail(&mut self, obj: T) {
  function insert_at_ith (line 71) | pub fn insert_at_ith(&mut self, index: u32, obj: T) {
  function delete_head (line 111) | pub fn delete_head(&mut self) -> Option<T> {
  function delete_tail (line 131) | pub fn delete_tail(&mut self) -> Option<T> {
  function delete_ith (line 146) | pub fn delete_ith(&mut self, index: u32) -> Option<T> {
  function get (line 186) | pub fn get(&self, index: i32) -> Option<&T> {
  function get_ith_node (line 190) | fn get_ith_node(node: Option<NonNull<Node<T>>>, index: i32) -> Option<No...
  method drop (line 202) | fn drop(&mut self) {
  method fmt (line 212) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  method fmt (line 224) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function insert_at_tail_works (line 239) | fn insert_at_tail_works() {
  function insert_at_head_works (line 251) | fn insert_at_head_works() {
  function insert_at_ith_can_add_to_tail (line 264) | fn insert_at_ith_can_add_to_tail() {
  function insert_at_ith_can_add_to_head (line 277) | fn insert_at_ith_can_add_to_head() {
  function insert_at_ith_can_add_to_middle (line 290) | fn insert_at_ith_can_add_to_middle() {
  function insert_at_ith_and_delete_at_ith_in_the_middle (line 310) | fn insert_at_ith_and_delete_at_ith_in_the_middle() {
  function insert_at_ith_and_delete_ith_work_over_many_iterations (line 340) | fn insert_at_ith_and_delete_ith_work_over_many_iterations() {
  function delete_tail_works (line 374) | fn delete_tail_works() {
  function delete_head_works (line 393) | fn delete_head_works() {
  function delete_ith_can_delete_at_tail (line 412) | fn delete_ith_can_delete_at_tail() {
  function delete_ith_can_delete_at_head (line 427) | fn delete_ith_can_delete_at_head() {
  function delete_ith_can_delete_in_middle (line 442) | fn delete_ith_can_delete_in_middle() {
  function create_numeric_list (line 462) | fn create_numeric_list() {
  function create_string_list (line 472) | fn create_string_list() {
  function get_by_index_in_numeric_list (line 482) | fn get_by_index_in_numeric_list() {
  function get_by_index_in_string_list (line 493) | fn get_by_index_in_string_list() {
  function delete_ith_panics_if_index_equals_length (line 505) | fn delete_ith_panics_if_index_equals_length() {

FILE: src/data_structures/probabilistic/bloom_filter.rs
  type BloomFilter (line 6) | pub trait BloomFilter<Item: Hash> {
    method insert (line 7) | fn insert(&mut self, item: Item);
    method contains (line 8) | fn contains(&self, item: &Item) -> bool;
  type BasicBloomFilter (line 26) | struct BasicBloomFilter<const CAPACITY: usize> {
  method default (line 31) | fn default() -> Self {
  function insert (line 39) | fn insert(&mut self, item: Item) {
  function contains (line 46) | fn contains(&self, item: &Item) -> bool {
  type SingleBinaryBloomFilter (line 65) | struct SingleBinaryBloomFilter {
    method insert (line 78) | fn insert(&mut self, item: T) {
    method contains (line 82) | fn contains(&self, item: &T) -> bool {
  function mask_128 (line 70) | fn mask_128<T: Hash>(hasher: &mut DefaultHasher, item: T) -> u128 {
  type MultiBinaryBloomFilter (line 104) | pub struct MultiBinaryBloomFilter {
    method with_dimensions (line 111) | pub fn with_dimensions(filter_size: usize, hash_count: usize) -> Self {
    method from_estimate (line 120) | pub fn from_estimate(
    method insert (line 137) | fn insert(&mut self, item: Item) {
    method contains (line 149) | fn contains(&self, item: &Item) -> bool {
  type TestSet (line 175) | struct TestSet {
  method arbitrary (line 181) | fn arbitrary(g: &mut Gen) -> Self {
  function basic_filter_must_not_return_false_negative (line 197) | fn basic_filter_must_not_return_false_negative(TestSet { to_insert, to_t...
  function binary_filter_must_not_return_false_negative (line 210) | fn binary_filter_must_not_return_false_negative(TestSet { to_insert, to_...
  function a_basic_filter_of_capacity_128_is_the_same_as_a_binary_filter (line 223) | fn a_basic_filter_of_capacity_128_is_the_same_as_a_binary_filter(
  constant FALSE_POSITIVE_MAX (line 241) | const FALSE_POSITIVE_MAX: f64 = 0.05;
  function a_multi_binary_bloom_filter_must_not_return_false_negatives (line 244) | fn a_multi_binary_bloom_filter_must_not_return_false_negatives(

FILE: src/data_structures/probabilistic/count_min_sketch.rs
  type CountMinSketch (line 17) | pub trait CountMinSketch {
    method increment (line 20) | fn increment(&mut self, item: Self::Item);
    method increment_by (line 21) | fn increment_by(&mut self, item: Self::Item, count: usize);
    method get_count (line 22) | fn get_count(&self, item: Self::Item) -> usize;
    type Item (line 122) | type Item = Item;
    method increment (line 124) | fn increment(&mut self, item: Self::Item) {
    method increment_by (line 128) | fn increment_by(&mut self, item: Self::Item, count: usize) {
    method get_count (line 138) | fn get_count(&self, item: Self::Item) -> usize {
  type HashCountMinSketch (line 91) | pub struct HashCountMinSketch<Item: Hash, const WIDTH: usize, const DEPT...
  method fmt (line 100) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method default (line 108) | fn default() -> Self {
  function hash_functions_should_hash_differently (line 163) | fn hash_functions_should_hash_differently() {
  function inspect_counts (line 182) | fn inspect_counts() {
  type TestItem (line 205) | struct TestItem {
  constant MAX_STR_LEN (line 210) | const MAX_STR_LEN: u8 = 30;
  constant MAX_COUNT (line 211) | const MAX_COUNT: usize = 20;
  method arbitrary (line 214) | fn arbitrary(g: &mut Gen) -> Self {
  function must_not_understimate_count (line 226) | fn must_not_understimate_count(test_items: Vec<TestItem>) {

FILE: src/data_structures/queue.rs
  type Queue (line 9) | pub struct Queue<T> {
  function new (line 15) | pub fn new() -> Queue<T> {
  function enqueue (line 22) | pub fn enqueue(&mut self, value: T) {
  function dequeue (line 27) | pub fn dequeue(&mut self) -> Option<T> {
  function peek_front (line 32) | pub fn peek_front(&self) -> Option<&T> {
  function peek_back (line 37) | pub fn peek_back(&self) -> Option<&T> {
  function len (line 42) | pub fn len(&self) -> usize {
  function is_empty (line 47) | pub fn is_empty(&self) -> bool {
  function drain (line 52) | pub fn drain(&mut self) {
  method default (line 59) | fn default() -> Queue<T> {
  function test_queue_functionality (line 69) | fn test_queue_functionality() {

FILE: src/data_structures/range_minimum_query.rs
  type RangeError (line 16) | pub enum RangeError {
  type RangeMinimumQuery (line 24) | pub struct RangeMinimumQuery<T: PartialOrd + Copy> {
  function new (line 42) | pub fn new(input: &[T]) -> RangeMinimumQuery<T> {
  function get_range_min (line 61) | pub fn get_range_min(&self, start: usize, end: usize) -> Result<T, Range...
  function build_sparse_table (line 97) | fn build_sparse_table<T: PartialOrd>(data: &[T]) -> Vec<Vec<usize>> {
  function simple_query_tests (line 165) | fn simple_query_tests() {
  function float_query_tests (line 180) | fn float_query_tests() {

FILE: src/data_structures/rb_tree.rs
  type Color (line 7) | enum Color {
  type RBNode (line 12) | pub struct RBNode<K: Ord, V> {
  function new (line 22) | fn new(key: K, value: V) -> RBNode<K, V> {
  type RBTree (line 34) | pub struct RBTree<K: Ord, V> {
  method default (line 39) | fn default() -> Self {
  function new (line 45) | pub fn new() -> RBTree<K, V> {
  function find (line 49) | pub fn find(&self, key: &K) -> Option<&V> {
  function insert (line 63) | pub fn insert(&mut self, key: K, value: V) {
  function delete (line 91) | pub fn delete(&mut self, key: &K) {
  function iter (line 223) | pub fn iter<'a>(&self) -> RBTreeIterator<'a, K, V> {
  function insert_fixup (line 237) | unsafe fn insert_fixup<K: Ord, V>(tree: &mut RBTree<K, V>, mut node: *mu...
  function delete_fixup (line 362) | unsafe fn delete_fixup<K: Ord, V>(tree: &mut RBTree<K, V>, mut parent: *...
  function left_rotate (line 508) | unsafe fn left_rotate<K: Ord, V>(tree: &mut RBTree<K, V>, x: *mut RBNode...
  function right_rotate (line 543) | unsafe fn right_rotate<K: Ord, V>(tree: &mut RBTree<K, V>, x: *mut RBNod...
  function replace_node (line 578) | unsafe fn replace_node<K: Ord, V>(
  type RBTreeIterator (line 593) | pub struct RBTreeIterator<'a, K: Ord, V> {
  type Item (line 598) | type Item = &'a RBNode<K, V>;
  method next (line 599) | fn next(&mut self) -> Option<Self::Item> {
  function find (line 621) | fn find() {
  function insert (line 633) | fn insert() {
  function delete (line 643) | fn delete() {
  function delete_edge_case_null_pointer_guard (line 658) | fn delete_edge_case_null_pointer_guard() {

FILE: src/data_structures/segment_tree.rs
  type SegmentTreeError (line 10) | pub enum SegmentTreeError {
  type SegmentTree (line 19) | pub struct SegmentTree<T, F>
  function from_vec (line 47) | pub fn from_vec(arr: &[T], merge: F) -> Self {
  function query (line 76) | pub fn query(&self, range: Range<usize>) -> Result<Option<T>, SegmentTre...
  function update (line 119) | pub fn update(&mut self, idx: usize, val: T) -> Result<(), SegmentTreeEr...
  function test_min_segments (line 145) | fn test_min_segments() {
  function test_max_segments (line 172) | fn test_max_segments() {
  function test_sum_segments (line 199) | fn test_sum_segments() {

FILE: src/data_structures/segment_tree_recursive.rs
  type SegmentTreeError (line 6) | pub enum SegmentTreeError {
  type SegmentTree (line 15) | pub struct SegmentTree<T, F>
  function from_vec (line 43) | pub fn from_vec(arr: &[T], merge_fn: F) -> Self {
  function build_recursive (line 63) | fn build_recursive(&mut self, arr: &[T], node_idx: usize, node_range: Ra...
  function query (line 87) | pub fn query(&self, target_range: Range<usize>) -> Result<Option<T>, Seg...
  function query_recursive (line 106) | fn query_recursive(
  function update (line 140) | pub fn update(&mut self, target_idx: usize, val: T) -> Result<(), Segmen...
  function update_recursive (line 156) | fn update_recursive(
  function test_min_segments (line 184) | fn test_min_segments() {
  function test_max_segments (line 211) | fn test_max_segments() {
  function test_sum_segments (line 238) | fn test_sum_segments() {

FILE: src/data_structures/skip_list.rs
  type Node (line 4) | struct Node<K: Ord, V> {
  function new (line 11) | pub fn new() -> Self {
  function make_node (line 21) | pub fn make_node(capacity: usize, key: K, value: V) -> Self {
  type SkipList (line 35) | pub struct SkipList<K: Ord, V> {
  function new (line 43) | pub fn new(max_level: usize) -> Self {
  function search (line 56) | pub fn search(&self, searched_key: K) -> Option<&V> {
  function insert (line 95) | pub fn insert(&mut self, searched_key: K, new_value: V) -> bool {
  function delete (line 154) | pub fn delete(&mut self, searched_key: K) -> bool {
  function iter (line 228) | pub fn iter(&self) -> Iter<'_, K, V> {
  method drop (line 234) | fn drop(&mut self) {
  function random_value (line 246) | fn random_value(max: usize) -> usize {
  type Iter (line 258) | pub struct Iter<'a, K: Ord, V> {
  function new (line 264) | pub fn new(skip_list: &'a SkipList<K, V>) -> Self {
  type Item (line 273) | type Item = (&'a K, &'a V);
  method next (line 275) | fn next(&mut self) -> Option<Self::Item> {
  function insert_and_delete (line 295) | fn insert_and_delete() {
  function iterator (line 316) | fn iterator() {
  function cannot_search (line 327) | fn cannot_search() {
  function delete_unsuccessfully (line 344) | fn delete_unsuccessfully() {
  function update_value_with_insert_operation (line 361) | fn update_value_with_insert_operation() {

FILE: src/data_structures/stack_using_singly_linked_list.rs
  type Stack (line 2) | pub struct Stack<T> {
  type Link (line 6) | type Link<T> = Option<Box<Node<T>>>;
  type Node (line 8) | struct Node<T> {
  function new (line 16) | pub fn new() -> Self {
  function push (line 27) | pub fn push(&mut self, elem: T) {
  function pop (line 46) | pub fn pop(&mut self) -> Result<T, &str> {
  function is_empty (line 56) | pub fn is_empty(&self) -> bool {
  function peek (line 61) | pub fn peek(&self) -> Option<&T> {
  function peek_mut (line 69) | pub fn peek_mut(&mut self) -> Option<&mut T> {
  function into_iter_for_stack (line 76) | pub fn into_iter_for_stack(self) -> IntoIter<T> {
  function iter (line 79) | pub fn iter(&self) -> Iter<'_, T> {
  function iter_mut (line 85) | pub fn iter_mut(&mut self) -> IterMut<'_, T> {
  method default (line 93) | fn default() -> Self {
  method drop (line 110) | fn drop(&mut self) {
  type IntoIter (line 124) | pub struct IntoIter<T>(Stack<T>);
  type Item (line 128) | type Item = T;
  method next (line 130) | fn next(&mut self) -> Option<Self::Item> {
  type Iter (line 135) | pub struct Iter<'a, T> {
  type Item (line 140) | type Item = &'a T;
  method next (line 141) | fn next(&mut self) -> Option<Self::Item> {
  type IterMut (line 150) | pub struct IterMut<'a, T> {
  type Item (line 155) | type Item = &'a mut T;
  method next (line 156) | fn next(&mut self) -> Option<Self::Item> {
  function basics (line 171) | fn basics() {
  function peek (line 197) | fn peek() {
  function into_iter (line 217) | fn into_iter() {
  function iter (line 231) | fn iter() {
  function iter_mut (line 244) | fn iter_mut() {

FILE: src/data_structures/treap.rs
  type TreapNode (line 10) | struct TreapNode<T: Ord> {
  type Treap (line 22) | pub struct Treap<T: Ord> {
  type Side (line 29) | enum Side {
  function new (line 35) | pub fn new() -> Treap<T> {
  function contains (line 43) | pub fn contains(&self, value: &T) -> bool {
  function insert (line 58) | pub fn insert(&mut self, value: T) -> bool {
  function remove (line 69) | pub fn remove(&mut self, value: &T) -> bool {
  function len (line 78) | pub fn len(&self) -> usize {
  function is_empty (line 83) | pub fn is_empty(&self) -> bool {
  function node_iter (line 88) | fn node_iter(&self) -> NodeIter<'_, T> {
  function iter (line 100) | pub fn iter(&self) -> Iter<'_, T> {
  function rand (line 108) | fn rand() -> usize {
  function insert (line 116) | fn insert<T: Ord>(tree: &mut Option<Box<TreapNode<T>>>, value: T) -> bool {
  function remove (line 139) | fn remove<T: Ord>(tree: &mut Option<Box<TreapNode<T>>>, value: &T) -> bo...
  function child (line 174) | fn child(&self, side: Side) -> &Option<Box<TreapNode<T>>> {
  function child_mut (line 182) | fn child_mut(&mut self, side: Side) -> &mut Option<Box<TreapNode<T>>> {
  function priority (line 190) | fn priority(&self, side: Side) -> usize {
  function rotate (line 195) | fn rotate(&mut self, side: Side) {
  function rebalance (line 209) | fn rebalance(&mut self) {
  function is_valid (line 222) | fn is_valid(&self) -> bool {
  method default (line 228) | fn default() -> Self {
  type Output (line 234) | type Output = Side;
  method not (line 236) | fn not(self) -> Self::Output {
  function from_iter (line 245) | fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
  type NodeIter (line 257) | struct NodeIter<'a, T: Ord> {
  type Item (line 262) | type Item = &'a TreapNode<T>;
  method next (line 264) | fn next(&mut self) -> Option<Self::Item> {
  type Iter (line 282) | pub struct Iter<'a, T: Ord> {
  type Item (line 287) | type Item = &'a T;
  method next (line 289) | fn next(&mut self) -> Option<&'a T> {
  function is_valid (line 302) | fn is_valid<T: Ord>(tree: &Treap<T>) -> bool {
  function len (line 307) | fn len() {
  function contains (line 313) | fn contains() {
  function insert (line 320) | fn insert() {
  function remove (line 329) | fn remove() {
  function sorted (line 338) | fn sorted() {
  function valid (line 344) | fn valid() {

FILE: src/data_structures/trie.rs
  type Node (line 11) | struct Node<Key: Default, Type: Default> {
  type Trie (line 21) | pub struct Trie<Key, Type>
  function new (line 39) | pub fn new() -> Self {
  function insert (line 50) | pub fn insert(&mut self, key: impl IntoIterator<Item = Key>, value: Type)
  function get (line 69) | pub fn get(&self, key: impl IntoIterator<Item = Key>) -> Option<&Type>
  function test_insertion_and_retrieval_with_strings (line 86) | fn test_insertion_and_retrieval_with_strings() {
  function test_insertion_and_retrieval_with_integers (line 101) | fn test_insertion_and_retrieval_with_integers() {
  function test_empty_trie (line 116) | fn test_empty_trie() {
  function test_insert_empty_key (line 124) | fn test_insert_empty_key() {
  function test_overlapping_keys (line 133) | fn test_overlapping_keys() {
  function test_partial_match (line 146) | fn test_partial_match() {

FILE: src/data_structures/union_find.rs
  type UnionFind (line 14) | pub struct UnionFind<T: Debug + Eq + Hash> {
  function with_capacity (line 23) | pub fn with_capacity(capacity: usize) -> Self {
  function insert (line 33) | pub fn insert(&mut self, item: T) {
  function find (line 42) | pub fn find(&mut self, value: &T) -> Option<usize> {
  function union (line 53) | pub fn union(&mut self, first_item: &T, sec_item: &T) -> Option<bool> {
  function find_by_key (line 62) | fn find_by_key(&mut self, key: usize) -> usize {
  function union_by_key (line 70) | fn union_by_key(&mut self, first_key: usize, sec_key: usize) -> bool {
  function is_same_set (line 93) | pub fn is_same_set(&mut self, first_item: &T, sec_item: &T) -> bool {
  function count (line 98) | pub fn count(&self) -> usize {
  method default (line 104) | fn default() -> Self {
  function from_iter (line 116) | fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
  function test_union_find (line 130) | fn test_union_find() {
  function test_spanning_tree (line 175) | fn test_spanning_tree() {
  function test_with_capacity (line 202) | fn test_with_capacity() {

FILE: src/data_structures/veb_tree.rs
  type VebTree (line 4) | pub struct VebTree {
    method new (line 16) | pub fn new(size: u32) -> VebTree {
    method high (line 41) | fn high(&self, value: u32) -> u32 {
    method low (line 45) | fn low(&self, value: u32) -> u32 {
    method index (line 49) | fn index(&self, cluster: u32, offset: u32) -> u32 {
    method min (line 53) | pub fn min(&self) -> u32 {
    method max (line 57) | pub fn max(&self) -> u32 {
    method iter (line 61) | pub fn iter(&self) -> VebTreeIter<'_> {
    method empty (line 66) | pub fn empty(&self) -> bool {
    method search (line 71) | pub fn search(&self, value: u32) -> bool {
    method insert_empty (line 82) | fn insert_empty(&mut self, value: u32) {
    method insert (line 89) | pub fn insert(&mut self, mut value: u32) {
    method succ (line 128) | pub fn succ(&self, pred: u32) -> Option<u32> {
    method pred (line 167) | pub fn pred(&self, succ: u32) -> Option<u32> {
  type VebTreeIter (line 212) | pub struct VebTreeIter<'a> {
  function new (line 218) | pub fn new(tree: &'a VebTree) -> VebTreeIter<'a> {
  type Item (line 225) | type Item = u32;
  method next (line 227) | fn next(&mut self) -> Option<u32> {
  function test_veb_tree (line 240) | fn test_veb_tree(size: u32, mut elements: Vec<u32>, exclude: Vec<u32>) {
  function test_empty (line 268) | fn test_empty() {
  function test_single (line 273) | fn test_single() {
  function test_two (line 278) | fn test_two() {
  function test_repeat_insert (line 287) | fn test_repeat_insert() {
  function test_linear (line 300) | fn test_linear() {
  function test_full (line 304) | fn test_full(size: u32) {
  function test_full_small (line 309) | fn test_full_small() {
  function test_full_256 (line 318) | fn test_full_256() {
  function test_10_256 (line 323) | fn test_10_256() {
  function test_100_256 (line 330) | fn test_100_256() {
  function test_100_300 (line 337) | fn test_100_300() {

FILE: src/dynamic_programming/catalan_numbers.rs
  function catalan_numbers (line 51) | pub fn catalan_numbers(upper_limit: usize) -> Vec<u64> {
  function test_catalan_numbers_basic (line 77) | fn test_catalan_numbers_basic() {
  function test_catalan_numbers_single (line 84) | fn test_catalan_numbers_single() {
  function test_catalan_numbers_extended (line 89) | fn test_catalan_numbers_extended() {
  function test_catalan_first_few (line 106) | fn test_catalan_first_few() {

FILE: src/dynamic_programming/coin_change.rs
  function coin_change (line 26) | pub fn coin_change(coins: &[usize], amount: usize) -> Option<usize> {

FILE: src/dynamic_programming/egg_dropping.rs
  function egg_drop (line 16) | pub fn egg_drop(eggs: usize, floors: usize) -> Option<usize> {

FILE: src/dynamic_programming/fibonacci.rs
  function fibonacci (line 9) | pub fn fibonacci(n: u32) -> u128 {
  function recursive_fibonacci (line 28) | pub fn recursive_fibonacci(n: u32) -> u128 {
  function _recursive_fibonacci (line 34) | fn _recursive_fibonacci(n: u32, previous: u128, current: u128) -> u128 {
  function classical_fibonacci (line 47) | pub fn classical_fibonacci(n: u32) -> u128 {
  function logarithmic_fibonacci (line 70) | pub fn logarithmic_fibonacci(n: u32) -> u128 {
  function _logarithmic_fibonacci (line 82) | fn _logarithmic_fibonacci(n: u32) -> (u128, u128) {
  function memoized_fibonacci (line 99) | pub fn memoized_fibonacci(n: u32) -> u128 {
  function _memoized_fibonacci (line 105) | fn _memoized_fibonacci(n: u32, cache: &mut HashMap<u32, u128>) -> u128 {
  function matrix_fibonacci (line 135) | pub fn matrix_fibonacci(n: u32) -> u128 {
  function matrix_power (line 146) | fn matrix_power(base: &Vec<Vec<u128>>, power: u32) -> Vec<Vec<u128>> {
  function matrix_multiply (line 156) | fn matrix_multiply(multiplier: &[Vec<u128>], multiplicand: &[Vec<u128>])...
  function binary_lifting_fibonacci (line 192) | pub fn binary_lifting_fibonacci(n: u32) -> u128 {
  function nth_fibonacci_number_modulo_m (line 212) | pub fn nth_fibonacci_number_modulo_m(n: i64, m: i64) -> i128 {
  function get_pisano_sequence_and_period (line 222) | fn get_pisano_sequence_and_period(m: i64) -> (i128, Vec<i128>) {
  function last_digit_of_the_sum_of_nth_fibonacci_number (line 257) | pub fn last_digit_of_the_sum_of_nth_fibonacci_number(n: i64) -> i64 {
  function test_fibonacci (line 292) | fn test_fibonacci() {
  function test_recursive_fibonacci (line 306) | fn test_recursive_fibonacci() {
  function test_classical_fibonacci (line 323) | fn test_classical_fibonacci() {
  function test_logarithmic_fibonacci (line 341) | fn test_logarithmic_fibonacci() {
  function test_iterative_and_recursive_equivalence (line 361) | fn test_iterative_and_recursive_equivalence() {
  function test_classical_and_combinatorial_are_off_by_one (line 379) | fn test_classical_and_combinatorial_are_off_by_one() {
  function test_memoized_fibonacci (line 394) | fn test_memoized_fibonacci() {
  function test_matrix_fibonacci (line 412) | fn test_matrix_fibonacci() {
  function test_binary_lifting_fibonacci (line 430) | fn test_binary_lifting_fibonacci() {
  function test_nth_fibonacci_number_modulo_m (line 448) | fn test_nth_fibonacci_number_modulo_m() {
  function test_last_digit_of_the_sum_of_nth_fibonacci_number (line 463) | fn test_last_digit_of_the_sum_of_nth_fibonacci_number() {

FILE: src/dynamic_programming/fractional_knapsack.rs
  function fractional_knapsack (line 1) | pub fn fractional_knapsack(mut capacity: f64, weights: Vec<f64>, values:...
  function test (line 39) | fn test() {
  function test2 (line 47) | fn test2() {
  function test3 (line 55) | fn test3() {
  function test4 (line 63) | fn test4() {
  function test5 (line 71) | fn test5() {
  function test6 (line 82) | fn test6() {
  function test_nan (line 91) | fn test_nan() {

FILE: src/dynamic_programming/integer_partition.rs
  function partition (line 37) | pub fn partition(m: i32) -> u128 {
  function test_partition_5 (line 77) | fn test_partition_5() {
  function test_partition_7 (line 82) | fn test_partition_7() {
  function test_partition_100 (line 88) | fn test_partition_100() {
  function test_partition_1000 (line 94) | fn test_partition_1000() {
  function test_partition_negative (line 100) | fn test_partition_negative() {
  function test_partition_zero (line 106) | fn test_partition_zero() {
  function test_partition_small_values (line 111) | fn test_partition_small_values() {

FILE: src/dynamic_programming/is_subsequence.rs
  function is_subsequence (line 18) | pub fn is_subsequence(sub: &str, main: &str) -> bool {

FILE: src/dynamic_programming/knapsack.rs
  type Item (line 8) | pub struct Item {
  type KnapsackSolution (line 15) | pub struct KnapsackSolution {
  function knapsack (line 45) | pub fn knapsack(capacity: usize, items: Vec<Item>) -> KnapsackSolution {
  function generate_knapsack_matrix (line 72) | fn generate_knapsack_matrix(
  function retrieve_knapsack_items (line 111) | fn retrieve_knapsack_items(

FILE: src/dynamic_programming/longest_common_subsequence.rs
  function longest_common_subsequence (line 28) | pub fn longest_common_subsequence(first_seq: &str, second_seq: &str) -> ...
  function initialize_lcs_lengths (line 38) | fn initialize_lcs_lengths(first_seq_chars: &[char], second_seq_chars: &[...
  function reconstruct_lcs (line 58) | fn reconstruct_lcs(

FILE: src/dynamic_programming/longest_common_substring.rs
  function longest_common_substring (line 20) | pub fn longest_common_substring(s1: &str, s2: &str) -> usize {

FILE: src/dynamic_programming/longest_continuous_increasing_subsequence.rs
  function longest_continuous_increasing_subsequence (line 17) | pub fn longest_continuous_increasing_subsequence<T: Ord>(arr: &[T]) -> &...

FILE: src/dynamic_programming/longest_increasing_subsequence.rs
  function longest_increasing_subsequence (line 7) | pub fn longest_increasing_subsequence<T: Ord + Clone>(input_array: &[T])...
  function test_empty_vec (line 54) | fn test_empty_vec() {
  function test_example_1 (line 59) | fn test_example_1() {
  function test_example_2 (line 67) | fn test_example_2() {
  function test_example_3 (line 75) | fn test_example_3() {
  function test_tle (line 83) | fn test_tle() {
  function test_negative_elements (line 106) | fn test_negative_elements() {

FILE: src/dynamic_programming/matrix_chain_multiply.rs
  type MatrixChainMultiplicationError (line 14) | pub enum MatrixChainMultiplicationError {
  function matrix_chain_multiply (line 35) | pub fn matrix_chain_multiply(

FILE: src/dynamic_programming/maximal_square.rs
  function maximal_square (line 15) | pub fn maximal_square(matrix: &mut [Vec<i32>]) -> i32 {
  function test (line 49) | fn test() {

FILE: src/dynamic_programming/maximum_subarray.rs
  type MaximumSubarrayError (line 7) | pub enum MaximumSubarrayError {
  function maximum_subarray (line 30) | pub fn maximum_subarray(array: &[isize]) -> Result<isize, MaximumSubarra...

FILE: src/dynamic_programming/minimum_cost_path.rs
  type MatrixError (line 5) | pub enum MatrixError {
  function minimum_cost_path (line 32) | pub fn minimum_cost_path(matrix: Vec<Vec<usize>>) -> Result<usize, Matri...

FILE: src/dynamic_programming/optimal_bst.rs
  function optimal_search_tree (line 13) | pub fn optimal_search_tree(freq: &[i32]) -> i32 {

FILE: src/dynamic_programming/palindrome_partitioning.rs
  function minimum_palindrome_partitions (line 38) | pub fn minimum_palindrome_partitions(s: &str) -> usize {
  function test_basic_cases (line 85) | fn test_basic_cases() {
  function test_edge_cases (line 97) | fn test_edge_cases() {
  function test_palindromes (line 109) | fn test_palindromes() {
  function test_non_palindromes (line 117) | fn test_non_palindromes() {
  function test_longer_strings (line 126) | fn test_longer_strings() {

FILE: src/dynamic_programming/rod_cutting.rs
  function rod_cut (line 14) | pub fn rod_cut(prices: &[usize]) -> usize {

FILE: src/dynamic_programming/smith_waterman.rs
  function score_function (line 59) | pub fn score_function(
  function smith_waterman (line 101) | pub fn smith_waterman(
  function traceback (line 173) | pub fn traceback(
  function test_score_function_match (line 359) | fn test_score_function_match() {
  function test_score_function_mismatch (line 365) | fn test_score_function_mismatch() {
  function test_score_function_gap (line 371) | fn test_score_function_gap() {
  function test_case_insensitive (line 377) | fn test_case_insensitive() {
  function test_custom_scoring_end_to_end (line 387) | fn test_custom_scoring_end_to_end() {
  function test_alignment_at_boundary (line 416) | fn test_alignment_at_boundary() {

FILE: src/dynamic_programming/snail.rs
  function snail (line 5) | pub fn snail<T: Copy>(matrix: &[Vec<T>]) -> Vec<T> {
  type Direction (line 42) | enum Direction {
    method snail_move (line 50) | pub fn snail_move(
  function test_empty (line 112) | fn test_empty() {
  function test_int (line 118) | fn test_int() {
  function test_char (line 124) | fn test_char() {
  function test_rect (line 137) | fn test_rect() {

FILE: src/dynamic_programming/subset_generation.rs
  function list_subset (line 4) | pub fn list_subset(
  function test_print_subset3 (line 46) | fn test_print_subset3() {
  function test_print_subset4 (line 72) | fn test_print_subset4() {
  function test_print_subset5 (line 93) | fn test_print_subset5() {
  function test_print_incorrect_subset (line 105) | fn test_print_incorrect_subset() {

FILE: src/dynamic_programming/subset_sum.rs
  function is_sum_subset (line 15) | pub fn is_sum_subset(arr: &[i32], required_sum: i32) -> bool {

FILE: src/dynamic_programming/task_assignment.rs
  function count_task_assignments (line 18) | pub fn count_task_assignments(task_performed: Vec<Vec<usize>>, total_tas...

FILE: src/dynamic_programming/trapped_rainwater.rs
  function trapped_rainwater (line 12) | pub fn trapped_rainwater(elevation_map: &[u32]) -> u32 {
  function calculate_max_values (line 35) | fn calculate_max_values(elevation_map: &[u32], reverse: bool) -> Vec<u32> {
  function create_iter (line 57) | fn create_iter(len: usize, reverse: bool) -> Box<dyn Iterator<Item = usi...

FILE: src/dynamic_programming/word_break.rs
  function word_break (line 12) | pub fn word_break(s: &str, word_dict: &[&str]) -> bool {
  function search (line 34) | fn search(trie: &Trie<char, bool>, s: &str, start: usize, memo: &mut Vec...

FILE: src/financial/depreciation.rs
  type DepreciationError (line 29) | pub enum DepreciationError {
    method fmt (line 43) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function validate_common (line 67) | fn validate_common(
  function straight_line_depreciation (line 111) | pub fn straight_line_depreciation(
  function diminishing_balance_depreciation (line 172) | pub fn diminishing_balance_depreciation(
  function units_of_production_depreciation (line 239) | pub fn units_of_production_depreciation(
  function sum_of_years_digits_depreciation (line 318) | pub fn sum_of_years_digits_depreciation(
  function double_declining_balance_depreciation (line 386) | pub fn double_declining_balance_depreciation(
  function sl_basic (line 438) | fn sl_basic() {
  function sl_six_years (line 445) | fn sl_six_years() {
  function sl_no_residual (line 451) | fn sl_no_residual() {
  function sl_sum_equals_depreciable_cost (line 457) | fn sl_sum_equals_depreciable_cost() {
  function sl_single_year (line 466) | fn sl_single_year() {
  function sl_err_zero_years (line 473) | fn sl_err_zero_years() {
  function sl_err_negative_purchase (line 481) | fn sl_err_negative_purchase() {
  function sl_err_residual_exceeds_purchase (line 489) | fn sl_err_residual_exceeds_purchase() {
  function db_sum_equals_depreciable_cost (line 499) | fn db_sum_equals_depreciable_cost() {
  function db_never_below_residual (line 509) | fn db_never_below_residual() {
  function db_err_rate_zero (line 522) | fn db_err_rate_zero() {
  function db_err_rate_above_one (line 530) | fn db_err_rate_above_one() {
  function up_sum_equals_depreciable_cost (line 540) | fn up_sum_equals_depreciable_cost() {
  function up_proportional_expenses (line 552) | fn up_proportional_expenses() {
  function up_err_units_mismatch (line 562) | fn up_err_units_mismatch() {
  function up_err_zero_total_units (line 570) | fn up_err_zero_total_units() {
  function syd_sum_equals_depreciable_cost (line 580) | fn syd_sum_equals_depreciable_cost() {
  function syd_first_year_fraction (line 589) | fn syd_first_year_fraction() {
  function syd_last_year_fraction (line 597) | fn syd_last_year_fraction() {
  function syd_decreasing_charges (line 605) | fn syd_decreasing_charges() {
  function syd_with_residual (line 614) | fn syd_with_residual() {
  function syd_single_year (line 623) | fn syd_single_year() {
  function syd_err_zero_years (line 630) | fn syd_err_zero_years() {
  function ddb_sum_equals_depreciable_cost (line 640) | fn ddb_sum_equals_depreciable_cost() {
  function ddb_first_year_is_double_sl (line 649) | fn ddb_first_year_is_double_sl() {
  function ddb_never_below_residual (line 657) | fn ddb_never_below_residual() {
  function ddb_switches_to_sl (line 669) | fn ddb_switches_to_sl() {
  function ddb_err_zero_years (line 678) | fn ddb_err_zero_years() {
  function ddb_err_residual_exceeds_purchase (line 686) | fn ddb_err_residual_exceeds_purchase() {

FILE: src/financial/equated_monthly_installments.rs
  function equated_monthly_installments (line 20) | pub fn equated_monthly_installments(
  function test_equated_monthly_installments (line 55) | fn test_equated_monthly_installments() {

FILE: src/financial/exponential_moving_average.rs
  function exponential_moving_average (line 35) | pub fn exponential_moving_average(
  function approx_eq (line 69) | fn approx_eq(a: f64, b: f64) -> bool {
  function test_basic_ema (line 74) | fn test_basic_ema() {
  function test_window_size_one (line 88) | fn test_window_size_one() {
  function test_single_price (line 101) | fn test_single_price() {
  function test_empty_prices (line 110) | fn test_empty_prices() {
  function test_zero_window_size_returns_error (line 119) | fn test_zero_window_size_returns_error() {

FILE: src/financial/finance_ratios.rs
  function return_on_investment (line 3) | pub fn return_on_investment(gain: f64, cost: f64) -> f64 {
  function debt_to_equity (line 7) | pub fn debt_to_equity(debt: f64, equity: f64) -> f64 {
  function gross_profit_margin (line 11) | pub fn gross_profit_margin(revenue: f64, cost: f64) -> f64 {
  function earnings_per_sale (line 15) | pub fn earnings_per_sale(net_income: f64, pref_dividend: f64, share_avg:...
  function test_return_on_investment (line 24) | fn test_return_on_investment() {
  function test_debt_to_equity (line 31) | fn test_debt_to_equity() {
  function test_gross_profit_margin (line 38) | fn test_gross_profit_margin() {
  function test_earnings_per_sale (line 45) | fn test_earnings_per_sale() {

FILE: src/financial/interest.rs
  function simple_interest (line 25) | pub fn simple_interest(
  function compound_interest (line 51) | pub fn compound_interest(
  function apr_interest (line 83) | pub fn apr_interest(
  function test_simple_interest (line 111) | fn test_simple_interest() {
  function test_compound_interest (line 147) | fn test_compound_interest() {
  function test_apr_interest (line 182) | fn test_apr_interest() {

FILE: src/financial/npv.rs
  function npv (line 5) | pub fn npv(cash_flows: &[f64], rate: f64) -> f64 {
  function test_npv_basic (line 20) | fn test_npv_basic() {
  function test_npv_zero_rate (line 29) | fn test_npv_zero_rate() {
  function test_npv_empty (line 37) | fn test_npv_empty() {

FILE: src/financial/npv_sensitivity.rs
  function npv_sensitivity (line 14) | pub fn npv_sensitivity(cash_flows: &[f64], discount_rates: &[f64]) -> Ve...
  function test_npv_sensitivity (line 32) | fn test_npv_sensitivity() {

FILE: src/financial/payback.rs
  function payback (line 4) | pub fn payback(cash_flow: &[f64]) -> Option<usize> {
  function test_payback (line 20) | fn test_payback() {
  function test_no_payback (line 26) | fn test_no_payback() {

FILE: src/financial/present_value.rs
  type PresentValueError (line 7) | pub enum PresentValueError {
  function present_value (line 12) | pub fn present_value(discount_rate: f64, cash_flows: Vec<f64>) -> Result...
  function round (line 29) | fn round(value: f64) -> f64 {

FILE: src/financial/treynor_ratio.rs
  function treynor_ratio (line 11) | pub fn treynor_ratio(portfolio_return: f64, risk_free_rate: f64, beta: f...
  function test_treynor_ratio (line 24) | fn test_treynor_ratio() {
  function test_treynor_ratio_empty_beta (line 31) | fn test_treynor_ratio_empty_beta() {

FILE: src/general/convex_hull.rs
  function sort_by_min_angle (line 3) | fn sort_by_min_angle(pts: &[(f64, f64)], min: &(f64, f64)) -> Vec<(f64, ...
  function calc_z_coord_vector_product (line 21) | fn calc_z_coord_vector_product(a: &(f64, f64), b: &(f64, f64), c: &(f64,...
  function convex_hull_graham (line 32) | pub fn convex_hull_graham(pts: &[(f64, f64)]) -> Vec<(f64, f64)> {
  function empty (line 72) | fn empty() {
  function not_enough_points (line 77) | fn not_enough_points() {
  function not_enough_points1 (line 83) | fn not_enough_points1() {
  function not_enough_points2 (line 90) | fn not_enough_points2() {
  function lots_of_points (line 98) | fn lots_of_points() {
  function lots_of_points2 (line 135) | fn lots_of_points2() {

FILE: src/general/fisher_yates_shuffle.rs
  constant DEFAULT (line 5) | const DEFAULT: u64 = 4294967296;
  function gen_range (line 7) | fn gen_range(range: usize, generator: &mut PCG32) -> usize {
  function fisher_yates_shuffle (line 11) | pub fn fisher_yates_shuffle(array: &mut [i32]) {

FILE: src/general/genetic.rs
  type Chromosome (line 13) | pub trait Chromosome<Rng: rand::RngExt, Eval> {
    method mutate (line 15) | fn mutate(&mut self, rng: &mut Rng);
    method crossover (line 18) | fn crossover(&self, other: &Self, rng: &mut Rng) -> Self;
    method fitness (line 22) | fn fitness(&self) -> Eval;
  type SelectionStrategy (line 25) | pub trait SelectionStrategy<Rng: rand::RngExt> {
    method new (line 26) | fn new(rng: Rng) -> Self;
    method select (line 31) | fn select<'a, Eval: Into<f64>, C: Chromosome<Rng, Eval>>(
  type RouletteWheel (line 40) | pub struct RouletteWheel<Rng: rand::RngExt> {
  function new (line 44) | fn new(rng: Rng) -> Self {
  function select (line 48) | fn select<'a, Eval: Into<f64>, C: Chromosome<Rng, Eval>>(
  type Tournament (line 89) | pub struct Tournament<const K: usize, Rng: rand::RngExt> {
  function new (line 93) | fn new(rng: Rng) -> Self {
  function select (line 97) | fn select<'a, Eval, C: Chromosome<Rng, Eval>>(
  type Comparator (line 119) | type Comparator<T> = Box<dyn FnMut(&T, &T) -> Ordering>;
  type GeneticAlgorithm (line 120) | pub struct GeneticAlgorithm<
  type GenericAlgorithmParams (line 136) | pub struct GenericAlgorithmParams {
  function init (line 149) | pub fn init(
  function solve (line 174) | pub fn solve(&mut self) -> Option<C> {
  function find_secret (line 232) | fn find_secret() {
  function solve_mastermind (line 318) | fn solve_mastermind() {

FILE: src/general/hanoi.rs
  function hanoi (line 1) | pub fn hanoi(n: i32, from: i32, to: i32, via: i32, moves: &mut Vec<(i32,...
  function hanoi_simple (line 14) | fn hanoi_simple() {

FILE: src/general/huffman_encoding.rs
  type HuffmanValue (line 7) | pub struct HuffmanValue {
  type HuffmanNode (line 16) | pub struct HuffmanNode<T> {
  method eq (line 24) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 30) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 38) | fn cmp(&self, other: &Self) -> Ordering {
  function get_alphabet (line 45) | pub fn get_alphabet(
  type HuffmanDictionary (line 74) | pub struct HuffmanDictionary<T> {
  function new (line 93) | pub fn new(alphabet: &[(T, u64)]) -> Option<Self> {
  function encode (line 154) | pub fn encode(&self, data: &[T]) -> HuffmanEncoding {
  type HuffmanEncoding (line 162) | pub struct HuffmanEncoding {
    method new (line 174) | pub fn new() -> Self {
    method add_data (line 181) | pub fn add_data(&mut self, data: HuffmanValue) {
    method get_bit (line 192) | fn get_bit(&self, pos: u64) -> bool {
    method decode (line 197) | pub fn decode<T: Clone + Copy + Ord>(&self, dict: &HuffmanDictionary<T...
  method default (line 168) | fn default() -> Self {
  function get_frequency (line 239) | fn get_frequency(bytes: &[u8]) -> Vec<(u8, u64)> {
  function empty_text (line 253) | fn empty_text() {
  function one_symbol_text (line 262) | fn one_symbol_text() {
  function test_decode_empty_encoding_struct (line 274) | fn test_decode_empty_encoding_struct() {
  function minimal_decode_end_check (line 293) | fn minimal_decode_end_check() {
  function test_decode_corrupted_stream_dead_end (line 307) | fn test_decode_corrupted_stream_dead_end() {
  function small_text (line 337) | fn small_text() {
  function lorem_ipsum (line 348) | fn lorem_ipsum() {

FILE: src/general/kadane_algorithm.rs
  function max_sub_array (line 21) | pub fn max_sub_array(nums: Vec<i32>) -> i32 {
  function test_kadanes_algorithm_positive (line 46) | fn test_kadanes_algorithm_positive() {
  function test_kadanes_algorithm_negative (line 55) | fn test_kadanes_algorithm_negative() {
  function test_kadanes_algorithm_mixed (line 64) | fn test_kadanes_algorithm_mixed() {
  function test_kadanes_algorithm_empty (line 73) | fn test_kadanes_algorithm_empty() {
  function test_kadanes_algorithm_single_positive (line 82) | fn test_kadanes_algorithm_single_positive() {

FILE: src/general/kmeans.rs
  function easy_univariate_clustering (line 108) | fn easy_univariate_clustering() {
  function easy_univariate_clustering_odd_number_of_data (line 124) | fn easy_univariate_clustering_odd_number_of_data() {
  function easy_bivariate_clustering (line 141) | fn easy_bivariate_clustering() {
  function high_dims (line 157) | fn high_dims() {

FILE: src/general/mex.rs
  function mex_using_set (line 7) | pub fn mex_using_set(arr: &[i64]) -> i64 {
  function mex_using_sort (line 26) | pub fn mex_using_sort(arr: &[i64]) -> i64 {
  type MexTests (line 41) | struct MexTests {
    method new (line 46) | fn new() -> Self {
    method test_function (line 62) | fn test_function(&self, f: fn(&[i64]) -> i64) {
  function test_mex_using_set (line 69) | fn test_mex_using_set() {
  function test_mex_using_sort (line 75) | fn test_mex_using_sort() {

FILE: src/general/permutations/heap.rs
  function heap_permute (line 5) | pub fn heap_permute<T: Clone + Debug>(arr: &[T]) -> Vec<Vec<T>> {
  function heap_recurse (line 16) | fn heap_recurse<T: Clone + Debug>(arr: &mut [T], k: usize, collector: &m...
  function test_3_different_values (line 42) | fn test_3_different_values() {
  function test_3_times_the_same_value (line 52) | fn test_3_times_the_same_value() {
  function test_some_elements (line 62) | fn test_some_elements(NotTooBigVec { inner: original }: NotTooBigVec) {

FILE: src/general/permutations/mod.rs
  function assert_permutations (line 14) | pub fn assert_permutations(original: &[i32], permutations: &[Vec<i32>]) {
  function assert_valid_permutation (line 26) | pub fn assert_valid_permutation(original: &[i32], permuted: &[i32]) {
  function test_valid_permutations (line 45) | fn test_valid_permutations() {
  function test_invalid_permutation_1 (line 56) | fn test_invalid_permutation_1() {
  function test_invalid_permutation_2 (line 62) | fn test_invalid_permutation_2() {
  function test_invalid_permutation_3 (line 68) | fn test_invalid_permutation_3() {
  function test_invalid_permutation_repeat (line 74) | fn test_invalid_permutation_repeat() {
  type NotTooBigVec (line 81) | pub struct NotTooBigVec {
  constant MAX_SIZE (line 85) | const MAX_SIZE: usize = 8;
  method arbitrary (line 87) | fn arbitrary(g: &mut Gen) -> Self {

FILE: src/general/permutations/naive.rs
  function permute (line 6) | pub fn permute<T: Clone + Debug>(arr: &[T]) -> Vec<Vec<T>> {
  function permute_recurse (line 22) | fn permute_recurse<T: Clone + Debug>(arr: &mut Vec<T>, k: usize, collect...
  function permute_unique (line 37) | pub fn permute_unique<T: Clone + Debug + Eq + Hash + Copy>(arr: &[T]) ->...
  function permute_recurse_unique (line 49) | fn permute_recurse_unique<T: Clone + Debug + Eq + Hash + Copy>(
  function test_3_different_values (line 90) | fn test_3_different_values() {
  function empty_array (line 100) | fn empty_array() {
  function test_3_times_the_same_value (line 107) | fn test_3_times_the_same_value() {
  function test_some_elements (line 117) | fn test_some_elements(NotTooBigVec { inner: original }: NotTooBigVec) {
  function test_unique_values (line 123) | fn test_unique_values() {

FILE: src/general/permutations/steinhaus_johnson_trotter.rs
  function steinhaus_johnson_trotter_permute (line 2) | pub fn steinhaus_johnson_trotter_permute<T: Clone>(array: &[T]) -> Vec<V...
  function test_3_different_values (line 37) | fn test_3_different_values() {
  function test_3_times_the_same_value (line 47) | fn test_3_times_the_same_value() {
  function test_some_elements (line 57) | fn test_some_elements(NotTooBigVec { inner: original }: NotTooBigVec) {

FILE: src/general/subarray_sum_equals_k.rs
  function subarray_sum_equals_k (line 19) | pub fn subarray_sum_equals_k(nums: &[i32], k: i32) -> i32 {
  function test_basic (line 45) | fn test_basic() {
  function test_single_element (line 51) | fn test_single_element() {
  function test_empty (line 57) | fn test_empty() {
  function test_negative_numbers (line 63) | fn test_negative_numbers() {
  function test_no_match (line 69) | fn test_no_match() {
  function test_multiple_matches (line 74) | fn test_multiple_matches() {

FILE: src/general/two_sum.rs
  function two_sum (line 18) | pub fn two_sum(nums: Vec<i32>, target: i32) -> Option<(usize, usize)> {
  function test (line 52) | fn test() {

FILE: src/geometry/closest_points.rs
  function cmp_x (line 4) | fn cmp_x(p1: &Point, p2: &Point) -> Ordering {
  function f64_cmp (line 12) | fn f64_cmp(a: &f64, b: &f64) -> Ordering {
  function closest_points (line 18) | pub fn closest_points(points: &[Point]) -> Option<(Point, Point)> {
  function closest_points_aux (line 29) | fn closest_points_aux(
  function eq (line 120) | fn eq(p1: Option<(Point, Point)>, p2: Option<(Point, Point)>) -> bool {
  function zero_points (line 140) | fn zero_points() {
  function one_points (line 146) | fn one_points() {
  function two_points (line 152) | fn two_points() {
  function three_points (line 161) | fn three_points() {
  function list_1 (line 170) | fn list_1() {
  function list_2 (line 191) | fn list_2() {
  function vertical_points (line 222) | fn vertical_points() {

FILE: src/geometry/graham_scan.rs
  function point_min (line 4) | fn point_min(a: &&Point, b: &&Point) -> Ordering {
  function graham_scan (line 15) | pub fn graham_scan(mut points: Vec<Point>) -> Vec<Point> {
  function test_graham (line 89) | fn test_graham(convex_hull: Vec<Point>, others: Vec<Point>) {
  function too_few_points (line 102) | fn too_few_points() {
  function duplicate_point (line 108) | fn duplicate_point() {
  function points_same_line (line 114) | fn points_same_line() {
  function triangle (line 125) | fn triangle() {
  function rectangle (line 134) | fn rectangle() {
  function triangle_with_points_in_middle (line 144) | fn triangle_with_points_in_middle() {
  function rectangle_with_points_in_middle (line 158) | fn rectangle_with_points_in_middle() {
  function star (line 174) | fn star() {
  function rectangle_with_points_on_same_line (line 193) | fn rectangle_with_points_on_same_line() {

FILE: src/geometry/jarvis_scan.rs
  function jarvis_march (line 6) | pub fn jarvis_march(points: Vec<Point>) -> Vec<Point> {
  function test_jarvis (line 76) | fn test_jarvis(convex_hull: Vec<Point>, others: Vec<Point>) {
  function too_few_points (line 89) | fn too_few_points() {
  function duplicate_point (line 95) | fn duplicate_point() {
  function points_same_line (line 101) | fn points_same_line() {
  function triangle (line 112) | fn triangle() {
  function rectangle (line 121) | fn rectangle() {
  function triangle_with_points_in_middle (line 131) | fn triangle_with_points_in_middle() {
  function rectangle_with_points_in_middle (line 145) | fn rectangle_with_points_in_middle() {
  function star (line 161) | fn star() {
  function rectangle_with_points_on_same_line (line 180) | fn rectangle_with_points_on_same_line() {

FILE: src/geometry/point.rs
  type Point (line 4) | pub struct Point {
    method new (line 10) | pub fn new(x: f64, y: f64) -> Point {
    method consecutive_orientation (line 15) | pub fn consecutive_orientation(&self, b: &Point, c: &Point) -> f64 {
    method cross_prod (line 21) | pub fn cross_prod(&self, other: &Point) -> f64 {
    method euclidean_distance (line 25) | pub fn euclidean_distance(&self, other: &Point) -> f64 {
  type Output (line 31) | type Output = Point;
  method sub (line 33) | fn sub(self, other: Self) -> Point {

FILE: src/geometry/polygon_points.rs
  type Ll (line 1) | type Ll = i64;
  type Pll (line 2) | type Pll = (Ll, Ll);
  function cross (line 4) | fn cross(x1: Ll, y1: Ll, x2: Ll, y2: Ll) -> Ll {
  function polygon_area (line 8) | pub fn polygon_area(pts: &[Pll]) -> Ll {
  function gcd (line 21) | fn gcd(mut a: Ll, mut b: Ll) -> Ll {
  function boundary (line 30) | fn boundary(pts: &[Pll]) -> Ll {
  function lattice_points (line 40) | pub fn lattice_points(pts: &[Pll]) -> Ll {
  function test_calculate_cross (line 51) | fn test_calculate_cross() {
  function test_polygon_3_coordinates (line 56) | fn test_polygon_3_coordinates() {
  function test_polygon_4_coordinates (line 62) | fn test_polygon_4_coordinates() {
  function test_gcd_multiple_of_common_factor (line 68) | fn test_gcd_multiple_of_common_factor() {
  function test_boundary (line 73) | fn test_boundary() {
  function test_lattice_points (line 79) | fn test_lattice_points() {

FILE: src/geometry/ramer_douglas_peucker.rs
  function ramer_douglas_peucker (line 3) | pub fn ramer_douglas_peucker(points: &[Point], epsilon: f64) -> Vec<Poin...
  function perpendicular_distance (line 29) | fn perpendicular_distance(p: &Point, a: &Point, b: &Point) -> f64 {
  function test_ramer_douglas_peucker_polygon (line 59) | fn test_ramer_douglas_peucker_polygon() {
  function test_ramer_douglas_peucker_polygonal_chain (line 84) | fn test_ramer_douglas_peucker_polygonal_chain() {
  function test_less_than_three_points (line 99) | fn test_less_than_three_points() {

FILE: src/geometry/segment.rs
  constant TOLERANCE (line 3) | const TOLERANCE: f64 = 0.0001;
  type Segment (line 5) | pub struct Segment {
    method new (line 11) | pub fn new(x1: f64, y1: f64, x2: f64, y2: f64) -> Segment {
    method from_points (line 18) | pub fn from_points(a: Point, b: Point) -> Segment {
    method direction (line 22) | pub fn direction(&self, p: &Point) -> f64 {
    method is_vertical (line 28) | pub fn is_vertical(&self) -> bool {
    method get_line_equation (line 33) | pub fn get_line_equation(&self) -> (f64, f64) {
    method compute_y_at_x (line 41) | pub fn compute_y_at_x(&self, x: f64) -> f64 {
    method is_colinear (line 46) | pub fn is_colinear(&self, p: &Point) -> bool {
    method colinear_point_on_segment (line 55) | pub fn colinear_point_on_segment(&self, p: &Point) -> bool {
    method on_segment (line 71) | pub fn on_segment(&self, p: &Point) -> bool {
    method intersects (line 78) | pub fn intersects(&self, other: &Segment) -> bool {
  function colinear (line 105) | fn colinear() {
  function colinear_vertical (line 127) | fn colinear_vertical() {
  function test_intersect (line 139) | fn test_intersect(s1: &Segment, s2: &Segment, result: bool) {
  function intersects (line 145) | fn intersects() {
  function intersects_endpoint_on_segment (line 159) | fn intersects_endpoint_on_segment() {
  function intersects_self (line 168) | fn intersects_self() {
  function too_short_to_intersect (line 175) | fn too_short_to_intersect() {
  function parallel_segments (line 185) | fn parallel_segments() {

FILE: src/graph/ant_colony_optimization.rs
  type City (line 22) | struct City {
    method distance_to (line 29) | fn distance_to(&self, other: &City) -> f64 {
  type AntColonyOptimization (line 37) | struct AntColonyOptimization {
    method new (line 50) | fn new(
    method solve (line 74) | fn solve(&mut self) -> Option<(Vec<usize>, f64)> {
    method construct_solutions (line 104) | fn construct_solutions(&self) -> Vec<Vec<usize>> {
    method construct_ant_solution (line 111) | fn construct_ant_solution(&self) -> Vec<usize> {
    method select_next_city (line 134) | fn select_next_city(&self, current: usize, unvisited: &HashSet<usize>)...
    method calculate_route_distance (line 166) | fn calculate_route_distance(&self, route: &[usize]) -> f64 {
    method update_pheromones (line 174) | fn update_pheromones(&mut self, routes: &[Vec<usize>]) {
  function ant_colony_optimization (line 236) | pub fn ant_colony_optimization(
  function test_city_distance (line 269) | fn test_city_distance() {
  function test_city_distance_negative (line 276) | fn test_city_distance_negative() {
  function test_aco_simple (line 283) | fn test_aco_simple() {
  function test_aco_larger_problem (line 300) | fn test_aco_larger_problem() {
  function test_aco_empty_cities (line 335) | fn test_aco_empty_cities() {
  function test_aco_single_city (line 342) | fn test_aco_single_city() {
  function test_default_parameters (line 353) | fn test_default_parameters() {
  function test_zero_ants (line 360) | fn test_zero_ants() {
  function test_zero_iterations (line 368) | fn test_zero_iterations() {
  function test_extreme_parameters (line 376) | fn test_extreme_parameters() {

FILE: src/graph/astar.rs
  type Graph (line 8) | type Graph<V, E> = BTreeMap<V, BTreeMap<V, E>>;
  type Candidate (line 11) | struct Candidate<V, E> {
  method partial_cmp (line 18) | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
  method cmp (line 26) | fn cmp(&self, other: &Self) -> std::cmp::Ordering {
  function astar (line 33) | pub fn astar<V: Ord + Copy, E: Ord + Copy + Add<Output = E> + Zero>(
  function null_heuristic (line 108) | fn null_heuristic<V, E: Zero>(_v: V) -> E {
  function add_edge (line 112) | fn add_edge<V: Ord + Copy, E: Ord>(graph: &mut Graph<V, E>, v1: V, v2: V...
  function single_vertex (line 118) | fn single_vertex() {
  function single_edge (line 127) | fn single_edge() {
  function graph_1 (line 136) | fn graph_1() {
  function test_heuristic (line 236) | fn test_heuristic() {

FILE: src/graph/bellman_ford.rs
  type Graph (line 6) | type Graph<V, E> = BTreeMap<V, BTreeMap<V, E>>;
  function bellman_ford (line 14) | pub fn bellman_ford<
  function add_edge (line 92) | fn add_edge<V: Ord + Copy, E: Ord>(graph: &mut Graph<V, E>, v1: V, v2: V...
  function single_vertex (line 98) | fn single_vertex() {
  function single_edge (line 109) | fn single_edge() {
  function tree_1 (line 126) | fn tree_1() {
  function graph_1 (line 150) | fn graph_1() {
  function graph_2 (line 194) | fn graph_2() {
  function graph_with_negative_loop (line 249) | fn graph_with_negative_loop() {

FILE: src/graph/bipartite_matching.rs
  type Graph (line 3) | type Graph = Vec<Vec<usize>>;
  type BipartiteMatching (line 5) | pub struct BipartiteMatching {
    method new (line 15) | pub fn new(num_vertices_grp1: usize, num_vertices_grp2: usize) -> Self {
    method add_edge (line 27) | pub fn add_edge(&mut self, u: usize, v: usize) {
    method try_kuhn (line 31) | fn try_kuhn(&mut self, cur: usize) -> bool {
    method kuhn (line 46) | pub fn kuhn(&mut self) {
    method print_matching (line 53) | pub fn print_matching(&self) {
    method bfs (line 61) | fn bfs(&self, dist: &mut [i32]) -> bool {
    method dfs (line 96) | fn dfs(&mut self, u: i32, dist: &mut Vec<i32>) -> bool {
    method hopcroft_karp (line 111) | pub fn hopcroft_karp(&mut self) -> i32 {
  function small_graph_kuhn (line 142) | fn small_graph_kuhn() {
  function small_graph_hopcroft (line 172) | fn small_graph_hopcroft() {
  function super_small_graph_kuhn (line 203) | fn super_small_graph_kuhn() {
  function super_small_graph_hopcroft (line 213) | fn super_small_graph_hopcroft() {
  function only_one_vertex_graph_kuhn (line 226) | fn only_one_vertex_graph_kuhn() {
  function only_one_vertex_graph_hopcroft (line 248) | fn only_one_vertex_graph_hopcroft() {

FILE: src/graph/breadth_first_search.rs
  function breadth_first_search (line 20) | pub fn breadth_first_search(graph: &Graph, root: Node, target: Node) -> ...
  type Node (line 50) | pub struct Node(u32);
    method from (line 69) | fn from(item: u32) -> Self {
    method value (line 75) | pub fn value(&self) -> u32 {
    method neighbors (line 79) | pub fn neighbors(&self, graph: &Graph) -> Vec<Node> {
  type Edge (line 53) | pub struct Edge(u32, u32);
    method from (line 90) | fn from(item: (u32, u32)) -> Self {
  type Graph (line 56) | pub struct Graph {
    method new (line 63) | pub fn new(nodes: Vec<Node>, edges: Vec<Edge>) -> Self {
  function graph1 (line 109) | fn graph1() -> Graph {
  function breadth_first_search_graph1_when_node_not_found_returns_none (line 120) | fn breadth_first_search_graph1_when_node_not_found_returns_none() {
  function breadth_first_search_graph1_when_target_8_should_evaluate_all_nodes_first (line 132) | fn breadth_first_search_graph1_when_target_8_should_evaluate_all_nodes_f...
  function graph2 (line 153) | fn graph2() -> Graph {
  function breadth_first_search_graph2_when_no_path_to_node_returns_none (line 179) | fn breadth_first_search_graph2_when_no_path_to_node_returns_none() {
  function breadth_first_search_graph2_should_find_path_from_4_to_1 (line 191) | fn breadth_first_search_graph2_should_find_path_from_4_to_1() {

FILE: src/graph/centroid_decomposition.rs
  type Adj (line 1) | type Adj = [Vec<usize>];
  constant IN_DECOMPOSITION (line 3) | const IN_DECOMPOSITION: u64 = 1 << 63;
  type CentroidDecomposition (line 15) | pub struct CentroidDecomposition {
    method new (line 29) | pub fn new(mut num_vertices: usize) -> Self {
    method put_in_decomposition (line 39) | fn put_in_decomposition(&mut self, v: usize, parent: usize) {
    method is_in_decomposition (line 44) | fn is_in_decomposition(&self, v: usize) -> bool {
    method dfs_size (line 47) | fn dfs_size(&mut self, v: usize, parent: usize, adj: &Adj) -> usize {
    method dfs_centroid (line 65) | fn dfs_centroid(&self, v: usize, size_thr: usize) -> usize {
    method decompose_subtree (line 72) | fn decompose_subtree(
    method decompose_tree (line 100) | pub fn decompose_tree(&mut self, adj: &Adj) {
  function calculate_height (line 112) | fn calculate_height(v: usize, heights: &mut [usize], parents: &mut [usiz...
  function single_path (line 119) | fn single_path() {
  function random_tree_height (line 139) | fn random_tree_height() {

FILE: src/graph/decremental_connectivity.rs
  type DecrementalConnectivity (line 12) | pub struct DecrementalConnectivity {
    method new (line 21) | pub fn new(adjacent: Vec<HashSet<usize>>) -> Result<Self, String> {
    method connected (line 37) | pub fn connected(&self, u: usize, v: usize) -> Option<bool> {
    method delete (line 44) | pub fn delete(&mut self, u: usize, v: usize) {
    method calc_component (line 70) | fn calc_component(&mut self) -> Vec<usize> {
    method is_smaller (line 93) | fn is_smaller(&mut self, u: usize, v: usize) -> bool {
    method dfs_step (line 112) | fn dfs_step(&mut self, queue: &mut Vec<usize>, dfs_id: usize) {
  function is_forest (line 126) | fn is_forest(adjacent: &Vec<HashSet<usize>>) -> bool {
  function has_cycle (line 139) | fn has_cycle(
  function construction_test (line 174) | fn construction_test() {
  function non_bidirectional_test (line 196) | fn non_bidirectional_test() {
  function delete_panic_test (line 215) | fn delete_panic_test() {
  function query_test (line 232) | fn query_test() {

FILE: src/graph/depth_first_search.rs
  function depth_first_search (line 8) | pub fn depth_first_search(graph: &Graph, root: Vertex, objective: Vertex...
  type Vertex (line 44) | pub struct Vertex(u32);
    method from (line 61) | fn from(item: u32) -> Self {
    method value (line 67) | pub fn value(&self) -> u32 {
    method neighbors (line 71) | pub fn neighbors(&self, graph: &Graph) -> VecDeque<Vertex> {
  type Edge (line 46) | pub struct Edge(u32, u32);
    method from (line 82) | fn from(item: (u32, u32)) -> Self {
  type Graph (line 48) | pub struct Graph {
    method new (line 55) | pub fn new(vertices: Vec<Vertex>, edges: Vec<Edge>) -> Self {
  function find_1_fail (line 92) | fn find_1_fail() {
  function find_1_sucess (line 111) | fn find_1_sucess() {
  function find_2_sucess (line 132) | fn find_2_sucess() {
  function find_3_sucess (line 163) | fn find_3_sucess() {

FILE: src/graph/depth_first_search_tic_tac_toe.rs
  type Position (line 34) | struct Position {
  type Players (line 40) | pub enum Players {
  type SinglePlayAction (line 47) | struct SinglePlayAction {
  type PlayActions (line 53) | pub struct PlayActions {
  function main (line 60) | fn main() {
  function display_board (line 136) | fn display_board(board: &[Vec<Players>]) {
  function available_positions (line 152) | fn available_positions(board: &[Vec<Players>]) -> Vec<Position> {
  function win_check (line 167) | fn win_check(player: Players, board: &[Vec<Players>]) -> bool {
  function minimax (line 195) | pub fn minimax(side: Players, board: &[Vec<Players>]) -> Option<PlayActi...
  function append_playaction (line 263) | fn append_playaction(
  function win_state_check (line 327) | fn win_state_check() {
  function win_state_check2 (line 337) | fn win_state_check2() {
  function block_win_move (line 349) | fn block_win_move() {
  function block_move (line 366) | fn block_move() {
  function expected_loss (line 382) | fn expected_loss() {

FILE: src/graph/detect_cycle.rs
  type DetectCycle (line 5) | pub trait DetectCycle {
    method detect_cycle_dfs (line 6) | fn detect_cycle_dfs(&self) -> bool;
    method detect_cycle_bfs (line 7) | fn detect_cycle_bfs(&self) -> bool;
    method detect_cycle_dfs (line 59) | fn detect_cycle_dfs(&self) -> bool {
    method detect_cycle_bfs (line 72) | fn detect_cycle_bfs(&self) -> bool {
    method detect_cycle_dfs (line 110) | fn detect_cycle_dfs(&self) -> bool {
    method detect_cycle_bfs (line 131) | fn detect_cycle_bfs(&self) -> bool {
  function undirected_graph_detect_cycle_dfs (line 11) | fn undirected_graph_detect_cycle_dfs<'a>(
  function undirected_graph_detect_cycle_bfs (line 32) | fn undirected_graph_detect_cycle_bfs<'a>(
  function directed_graph_detect_cycle_dfs (line 87) | fn directed_graph_detect_cycle_dfs<'a>(
  function get_undirected_single_node_with_loop (line 172) | fn get_undirected_single_node_with_loop() -> UndirectedGraph {
  function get_directed_single_node_with_loop (line 177) | fn get_directed_single_node_with_loop() -> DirectedGraph {
  function get_undirected_two_nodes_connected (line 182) | fn get_undirected_two_nodes_connected() -> UndirectedGraph {
  function get_directed_two_nodes_connected (line 187) | fn get_directed_two_nodes_connected() -> DirectedGraph {
  function get_directed_two_nodes (line 193) | fn get_directed_two_nodes() -> DirectedGraph {
  function get_undirected_triangle (line 198) | fn get_undirected_triangle() -> UndirectedGraph {
  function get_directed_triangle (line 205) | fn get_directed_triangle() -> DirectedGraph {
  function get_undirected_triangle_with_tail (line 212) | fn get_undirected_triangle_with_tail() -> UndirectedGraph {
  function get_directed_triangle_with_tail (line 220) | fn get_directed_triangle_with_tail() -> DirectedGraph {
  function get_undirected_graph_with_cycle (line 228) | fn get_undirected_graph_with_cycle() -> UndirectedGraph {
  function get_undirected_graph_without_cycle (line 237) | fn get_undirected_graph_without_cycle() -> UndirectedGraph {
  function get_directed_graph_with_cycle (line 245) | fn get_directed_graph_with_cycle() -> DirectedGraph {
  function get_directed_graph_without_cycle (line 254) | fn get_directed_graph_without_cycle() -> DirectedGraph {

FILE: src/graph/dijkstra.rs
  type Graph (line 4) | type Graph<V, E> = BTreeMap<V, BTreeMap<V, E>>;
  function dijkstra (line 15) | pub fn dijkstra<V: Ord + Copy, E: Ord + Copy + Add<Output = E>>(
  function add_edge (line 59) | fn add_edge<V: Ord + Copy, E: Ord>(graph: &mut Graph<V, E>, v1: V, v2: V...
  function single_vertex (line 65) | fn single_vertex() {
  function single_edge (line 76) | fn single_edge() {
  function tree_1 (line 93) | fn tree_1() {
  function graph_1 (line 117) | fn graph_1() {

FILE: src/graph/dinic_maxflow.rs
  type Graph (line 7) | type Graph = Vec<Vec<usize>>;
  type FlowEdge (line 10) | pub struct FlowEdge<T> {
  type FlowResultEdge (line 16) | pub struct FlowResultEdge<T> {
  function new (line 25) | pub fn new(sink: usize, capacity: T) -> Self {
  type DinicMaxFlow (line 34) | pub struct DinicMaxFlow<T> {
  function new (line 60) | pub fn new(source: usize, sink: usize, num_vertices: usize) -> Self {
  function add_edge (line 74) | pub fn add_edge(&mut self, source: usize, sink: usize, capacity: T) {
  function bfs (line 84) | fn bfs(&mut self) -> bool {
  function dfs (line 106) | fn dfs(&mut self, v: usize, pushed: T) -> T {
  function find_maxflow (line 134) | pub fn find_maxflow(&mut self, infinite_flow: T) -> T {
  function get_flow_edges (line 155) | pub fn get_flow_edges(&mut self, infinite_flow: T) -> Vec<FlowResultEdge...
  function small_graph (line 182) | fn small_graph() {

FILE: src/graph/disjoint_set_union.rs
  type DSUNode (line 7) | pub struct DSUNode {
  type DisjointSetUnion (line 17) | pub struct DisjointSetUnion {
    method new (line 32) | pub fn new(num_elements: usize) -> DisjointSetUnion {
    method find_set (line 56) | pub fn find_set(&mut self, element: usize) -> usize {
    method merge (line 75) | pub fn merge(&mut self, first_elem: usize, sec_elem: usize) -> usize {
  function test_disjoint_set_union (line 101) | fn test_disjoint_set_union() {

FILE: src/graph/eulerian_path.rs
  function find_eulerian_path (line 17) | pub fn find_eulerian_path(node_count: usize, edge_list: Vec<(usize, usiz...
  type EulerianPathSolver (line 28) | pub struct EulerianPathSolver {
    method new (line 47) | pub fn new(adjacency_list: Vec<Vec<usize>>) -> Self {
    method find_path (line 65) | fn find_path(&mut self) -> Option<Vec<usize>> {
    method initialize_degrees (line 88) | fn initialize_degrees(&mut self) {
    method has_eulerian_path (line 103) | fn has_eulerian_path(&self) -> bool {
    method get_start_node (line 128) | fn get_start_node(&self) -> usize {
    method depth_first_search (line 144) | fn depth_first_search(&mut self, curr_node: usize) {

FILE: src/graph/floyd_warshall.rs
  type Graph (line 5) | type Graph<V, E> = BTreeMap<V, BTreeMap<V, E>>;
  function floyd_warshall (line 17) | pub fn floyd_warshall<V: Ord + Copy, E: Ord + Copy + Add<Output = E> + n...
  function add_edge (line 73) | fn add_edge<V: Ord + Copy, E: Ord + Copy>(graph: &mut Graph<V, E>, v1: V...
  function bi_add_edge (line 77) | fn bi_add_edge<V: Ord + Copy, E: Ord + Copy>(graph: &mut Graph<V, E>, v1...
  function single_vertex (line 83) | fn single_vertex() {
  function single_edge (line 94) | fn single_edge() {
  function graph_1 (line 117) | fn graph_1() {

FILE: src/graph/ford_fulkerson.rs
  type FordFulkersonError (line 10) | pub enum FordFulkersonError {
  function bfs (line 30) | fn bfs(graph: &[Vec<usize>], source: usize, sink: usize, parent: &mut [u...
  function validate_ford_fulkerson_input (line 71) | fn validate_ford_fulkerson_input(
  function ford_fulkerson (line 107) | pub fn ford_fulkerson(

FILE: src/graph/graph_enumeration.rs
  type Graph (line 3) | type Graph<Vertex> = BTreeMap<Vertex, Vec<Vertex>>;
  function enumerate_graph (line 13) | pub fn enumerate_graph<V: Ord + Clone>(adj: &Graph<V>) -> Vec<Vec<usize>> {
  function add_edge (line 29) | fn add_edge<V: Ord + Clone>(graph: &mut Graph<V>, a: V, b: V) {
  function string_vertices (line 35) | fn string_vertices() {
  function integer_vertices (line 51) | fn integer_vertices() {

FILE: src/graph/heavy_light_decomposition.rs
  type Adj (line 19) | type Adj = [Vec<usize>];
  type HeavyLightDecomposition (line 21) | pub struct HeavyLightDecomposition {
    method new (line 39) | pub fn new(mut num_vertices: usize) -> Self {
    method dfs (line 48) | fn dfs(&mut self, v: usize, parent: usize, adj: &Adj) -> usize {
    method decompose (line 66) | pub fn decompose(&mut self, root: usize, adj: &Adj) {
    method decompose_path (line 71) | fn decompose_path(&mut self, v: usize, parent: usize, head: usize, adj...
  type LinearCongruenceGenerator (line 94) | struct LinearCongruenceGenerator {
    method new (line 102) | fn new(multiplier: u32, increment: u32, state: u32) -> Self {
    method next (line 109) | fn next(&mut self) -> u32 {
  function get_num_paths (line 116) | fn get_num_paths(
  function single_path (line 141) | fn single_path() {
  function random_tree (line 158) | fn random_tree() {

FILE: src/graph/kosaraju.rs
  type Graph (line 2) | pub struct Graph {
    method new (line 9) | pub fn new(vertices: usize) -> Self {
    method add_edge (line 17) | pub fn add_edge(&mut self, u: usize, v: usize) {
    method dfs (line 22) | pub fn dfs(&self, node: usize, visited: &mut Vec<bool>, stack: &mut Ve...
    method dfs_scc (line 32) | pub fn dfs_scc(&self, node: usize, visited: &mut Vec<bool>, scc: &mut ...
  function kosaraju (line 43) | pub fn kosaraju(graph: &Graph) -> Vec<Vec<usize>> {
  function test_kosaraju_single_sccs (line 71) | fn test_kosaraju_single_sccs() {
  function test_kosaraju_multiple_sccs (line 88) | fn test_kosaraju_multiple_sccs() {
  function test_kosaraju_multiple_sccs1 (line 113) | fn test_kosaraju_multiple_sccs1() {
  function test_kosaraju_no_scc (line 134) | fn test_kosaraju_no_scc() {
  function test_kosaraju_empty_graph (line 150) | fn test_kosaraju_empty_graph() {

FILE: src/graph/lee_breadth_first_search.rs
  function validate (line 5) | fn validate(matrix: &[Vec<i32>], visited: &[Vec<bool>], row: isize, col:...
  function lee (line 11) | pub fn lee(matrix: Vec<Vec<i32>>, source: (usize, usize), destination: (...
  function test_lee_exists (line 61) | fn test_lee_exists() {
  function test_lee_does_not_exist (line 75) | fn test_lee_does_not_exist() {
  function test_source_equals_destination (line 89) | fn test_source_equals_destination() {
  function test_lee_exists_2 (line 103) | fn test_lee_exists_2() {

FILE: src/graph/lowest_common_ancestor.rs
  type LowestCommonAncestorOnline (line 19) | pub struct LowestCommonAncestorOnline {
    method get_parent (line 29) | fn get_parent(&self, v: usize, i: usize) -> usize {
    method num_parents (line 33) | fn num_parents(&self, v: usize) -> usize {
    method new (line 36) | pub fn new(num_vertices: usize) -> Self {
    method fill_sparse_table (line 44) | pub fn fill_sparse_table(
    method get_ancestor (line 69) | pub fn get_ancestor(&self, mut v: usize, mut u: usize) -> usize {
  type LCAQuery (line 101) | pub struct LCAQuery {
  type QueryAnswer (line 107) | pub struct QueryAnswer {
  type LowestCommonAncestorOffline (line 112) | pub struct LowestCommonAncestorOffline {
    method new (line 124) | pub fn new(num_vertices: usize) -> Self {
    method add_query (line 131) | pub fn add_query(&mut self, u: usize, v: usize, query_id: usize) {
    method calculate_answers (line 141) | fn calculate_answers(
    method answer_queries (line 169) | pub fn answer_queries(&mut self, root: usize, adj: &[Vec<usize>]) -> V...
  function small_binary_tree (line 180) | fn small_binary_tree() {

FILE: src/graph/minimum_spanning_tree.rs
  type Edge (line 8) | pub struct Edge {
    method new (line 19) | pub fn new(source: usize, destination: usize, cost: usize) -> Self {
  function kruskal (line 47) | pub fn kruskal(mut edges: Vec<Edge>, num_vertices: usize) -> Option<(usi...

FILE: src/graph/prim.rs
  type Graph (line 5) | type Graph<V, E> = BTreeMap<V, BTreeMap<V, E>>;
  function add_edge (line 7) | fn add_edge<V: Ord + Copy, E: Ord + Add + Copy>(graph: &mut Graph<V, E>,...
  function prim (line 13) | pub fn prim<V: Ord + Copy + std::fmt::Debug, E: Ord + Add + Copy + std::...
  function prim_with_start (line 24) | pub fn prim_with_start<V: Ord + Copy, E: Ord + Add + Copy>(
  function empty (line 66) | fn empty() {
  function single_vertex (line 71) | fn single_vertex() {
  function single_edge (line 79) | fn single_edge() {
  function tree_1 (line 88) | fn tree_1() {
  function tree_2 (line 103) | fn tree_2() {
  function tree_3 (line 117) | fn tree_3() {
  function graph_1 (line 129) | fn graph_1() {
  function graph_2 (line 152) | fn graph_2() {
  function graph_3 (line 176) | fn graph_3() {

FILE: src/graph/prufer_code.rs
  type Graph (line 3) | type Graph<V> = BTreeMap<V, Vec<V>>;
  function prufer_encode (line 5) | pub fn prufer_encode<V: Ord + Copy>(tree: &Graph<V>) -> Vec<V> {
  function add_directed_edge (line 34) | fn add_directed_edge<V: Ord + Copy>(tree: &mut Graph<V>, a: V, b: V) {
  function add_edge (line 39) | fn add_edge<V: Ord + Copy>(tree: &mut Graph<V>, a: V, b: V) {
  function prufer_decode (line 44) | pub fn prufer_decode<V: Ord + Copy>(code: &[V], vertex_list: &[V]) -> Gr...
  function equal_graphs (line 78) | fn equal_graphs<V: Ord + Copy>(g1: &mut Graph<V>, g2: &mut Graph<V>) -> ...
  function small_trees (line 89) | fn small_trees() {

FILE: src/graph/strongly_connected_components.rs
  type StronglyConnectedComponents (line 11) | pub struct StronglyConnectedComponents {
    method new (line 54) | pub fn new(mut num_vertices: usize) -> Self {
    method dfs (line 64) | fn dfs(&mut self, v: usize, adj: &[Vec<usize>]) -> u64 {
    method find_components (line 95) | pub fn find_components(&mut self, adj: &[Vec<usize>]) {
  constant NOT_DONE (line 31) | const NOT_DONE: u64 = 1 << 63;
  function set_done (line 34) | fn set_done(vertex_state: &mut u64) {
  function is_in_stack (line 39) | fn is_in_stack(vertex_state: u64) -> bool {
  function is_unvisited (line 44) | fn is_unvisited(vertex_state: u64) -> bool {
  function get_discover_time (line 49) | fn get_discover_time(vertex_state: u64) -> u64 {
  function acyclic (line 110) | fn acyclic() {
  function cycle (line 120) | fn cycle() {
  function dumbbell (line 130) | fn dumbbell() {
  function connected_dumbbell (line 148) | fn connected_dumbbell() {

FILE: src/graph/tarjans_ssc.rs
  type Graph (line 1) | pub struct Graph {
    method new (line 7) | pub fn new(n: usize) -> Self {
    method add_edge (line 14) | pub fn add_edge(&mut self, u: usize, v: usize) {
  function tarjan_scc (line 18) | pub fn tarjan_scc(graph: &Graph) -> Vec<Vec<usize>> {
  function test_tarjan_scc (line 80) | fn test_tarjan_scc() {

FILE: src/graph/topological_sort.rs
  type TopoligicalSortError (line 6) | pub enum TopoligicalSortError {
  type TopologicalSortResult (line 10) | type TopologicalSortResult<Node> = Result<Vec<Node>, TopoligicalSortError>;
  function topological_sort (line 16) | pub fn topological_sort<Node: Hash + Eq + Copy>(
  function is_valid_sort (line 73) | fn is_valid_sort<Node: Eq>(sorted: &[Node], graph: &[(Node, Node)]) -> b...
  function it_works (line 88) | fn it_works() {
  function test_wikipedia_example (line 98) | fn test_wikipedia_example() {
  function test_cyclic_graph (line 117) | fn test_cyclic_graph() {

FILE: src/graph/two_satisfiability.rs
  type Condition (line 3) | pub type Condition = (i64, i64);
  type Graph (line 4) | type Graph = Vec<Vec<usize>>;
  function variable (line 7) | fn variable(var: i64) -> usize {
  function solve_two_satisfiability (line 18) | pub fn solve_two_satisfiability(
  function check_answer (line 53) | fn check_answer(expression: &[Condition], answers: &[bool]) -> bool {
  function basic_test (line 72) | fn basic_test() {
  function big_test (line 95) | fn big_test() {

FILE: src/greedy/minimum_coin_change.rs
  function find_minimum_change (line 170) | pub fn find_minimum_change(denominations: &[i32], value: i32) -> Vec<i32> {
  function test_indian_currency_standard (line 199) | fn test_indian_currency_standard() {
  function test_large_amount (line 207) | fn test_large_amount() {
  function test_zero_value (line 218) | fn test_zero_value() {
  function test_negative_value (line 225) | fn test_negative_value() {
  function test_non_standard_denominations (line 232) | fn test_non_standard_denominations() {
  function test_single_denomination (line 243) | fn test_single_denomination() {
  function test_exact_denomination (line 250) | fn test_exact_denomination() {
  function test_empty_denominations (line 257) | fn test_empty_denominations() {
  function test_unsorted_denominations (line 264) | fn test_unsorted_denominations() {
  function test_usd_currency (line 272) | fn test_usd_currency() {

FILE: src/greedy/smallest_range.rs
  function smallest_range (line 31) | pub fn smallest_range(nums: &[&[i64]]) -> Option<[i64; 2]> {
  function mixed_lists (line 83) | fn mixed_lists() {
  function identical_lists (line 91) | fn identical_lists() {
  function negative_and_positive (line 99) | fn negative_and_positive() {
  function non_overlapping (line 107) | fn non_overlapping() {
  function all_zeros (line 115) | fn all_zeros() {
  function empty_lists (line 123) | fn empty_lists() {
  function single_elements (line 128) | fn single_elements() {
  function single_list (line 133) | fn single_list() {
  function one_empty_among_non_empty (line 138) | fn one_empty_among_non_empty() {

FILE: src/greedy/stable_matching.rs
  function initialize_men (line 3) | fn initialize_men(
  function initialize_women (line 17) | fn initialize_women(
  function precompute_woman_ranks (line 27) | fn precompute_woman_ranks(
  function process_proposal (line 41) | fn process_proposal(
  function woman_prefers_new_man (line 78) | fn woman_prefers_new_man(
  function engage_man (line 88) | fn engage_man(
  function finalize_matches (line 105) | fn finalize_matches(man_engaged: HashMap<String, Option<String>>) -> Has...
  function stable_matching (line 115) | pub fn stable_matching(
  function test_stable_matching_scenario_1 (line 146) | fn test_stable_matching_scenario_1() {
  function test_stable_matching_empty (line 195) | fn test_stable_matching_empty() {
  function test_stable_matching_duplicate_preferences (line 204) | fn test_stable_matching_duplicate_preferences() {
  function test_stable_matching_single_pair (line 225) | fn test_stable_matching_single_pair() {
  function test_woman_prefers_new_man (line 235) | fn test_woman_prefers_new_man() {

FILE: src/machine_learning/cholesky.rs
  function cholesky (line 1) | pub fn cholesky(mat: Vec<f64>, n: usize) -> Vec<f64> {
  function test_cholesky (line 38) | fn test_cholesky() {
  function transpose_matrix (line 53) | fn transpose_matrix(mat: &[f64], n: usize) -> Vec<f64> {
  function matrix_multiply (line 59) | fn matrix_multiply(mat1: &[f64], mat2: &[f64], n: usize) -> Vec<f64> {
  function test_matrix_operations (line 70) | fn test_matrix_operations() {
  function empty_matrix (line 86) | fn empty_matrix() {
  function matrix_with_all_zeros (line 93) | fn matrix_with_all_zeros() {

FILE: src/machine_learning/decision_tree.rs
  type TreeNode (line 6) | enum TreeNode {
  function calculate_entropy (line 21) | fn calculate_entropy(labels: &[f64]) -> f64 {
  function find_best_split (line 57) | fn find_best_split(data: &[(Vec<f64>, f64)], feature_index: usize) -> Op...
  function find_best_split_feature (line 114) | fn find_best_split_feature(
  function get_majority_class (line 144) | fn get_majority_class(labels: &[f64]) -> f64 {
  function build_tree (line 180) | fn build_tree(
  function predict_tree (line 268) | fn predict_tree(tree: &TreeNode, features: &[f64]) -> f64 {
  type DecisionTree (line 288) | pub struct DecisionTree {
    method fit (line 293) | pub fn fit(
    method predict (line 319) | pub fn predict(&self, test_point: &[f64]) -> Option<f64> {
    method predict_batch (line 328) | pub fn predict_batch(&self, test_points: &[Vec<f64>]) -> Vec<Option<f6...
  function decision_tree (line 337) | pub fn decision_tree(
  function test_decision_tree_simple_xor (line 352) | fn test_decision_tree_simple_xor() {
  function test_decision_tree_linearly_separable (line 375) | fn test_decision_tree_linearly_separable() {
  function test_decision_tree_one_feature (line 395) | fn test_decision_tree_one_feature() {
  function test_decision_tree_multiple_classes (line 415) | fn test_decision_tree_multiple_classes() {
  function test_decision_tree_empty_training_data (line 436) | fn test_decision_tree_empty_training_data() {
  function test_decision_tree_empty_features (line 443) | fn test_decision_tree_empty_features() {
  function test_decision_tree_max_depth (line 450) | fn test_decision_tree_max_depth() {
  function test_decision_tree_min_samples_split (line 467) | fn test_decision_tree_min_samples_split() {
  function test_decision_tree_predict_batch (line 484) | fn test_decision_tree_predict_batch() {
  function test_decision_tree_convenience_function (line 506) | fn test_decision_tree_convenience_function() {
  function test_calculate_entropy (line 529) | fn test_calculate_entropy() {
  function test_get_majority_class (line 544) | fn test_get_majority_class() {

FILE: src/machine_learning/k_means.rs
  function get_distance (line 3) | fn get_distance(p1: &(f64, f64), p2: &(f64, f64)) -> f64 {
  function find_nearest (line 10) | fn find_nearest(data_point: &(f64, f64), centroids: &[(f64, f64)]) -> u32 {
  function k_means (line 25) | pub fn k_means(data_points: Vec<(f64, f64)>, n_clusters: usize, max_iter...
  function test_k_means (line 77) | fn test_k_means() {

FILE: src/machine_learning/k_nearest_neighbors.rs
  function euclidean_distance (line 5) | fn euclidean_distance(p1: &[f64], p2: &[f64]) -> f64 {
  function k_nearest_neighbors (line 17) | pub fn k_nearest_neighbors(
  function test_standard_knn (line 58) | fn test_standard_knn() {
  function test_one_dimensional_knn (line 78) | fn test_one_dimensional_knn() {
  function test_knn_empty_data (line 94) | fn test_knn_empty_data() {
  function test_knn_invalid_k (line 102) | fn test_knn_invalid_k() {
  function test_euclidean_distance_different_dimensions (line 116) | fn test_euclidean_distance_different_dimensions() {

FILE: src/machine_learning/linear_regression.rs
  function linear_regression (line 2) | pub fn linear_regression(data_points: Vec<(f64, f64)>) -> Option<(f64, f...
  function test_linear_regression (line 37) | fn test_linear_regression() {
  function test_empty_list_linear_regression (line 45) | fn test_empty_list_linear_regression() {

FILE: src/machine_learning/logistic_regression.rs
  function logistic_regression (line 5) | pub fn logistic_regression(
  function derivative (line 24) | fn derivative(params: &[f64], data_points: &[(Vec<f64>, f64)]) -> Vec<f6...
  function test_logistic_regression_simple (line 51) | fn test_logistic_regression_simple() {
  function test_logistic_regression_extreme_data (line 70) | fn test_logistic_regression_extreme_data() {
  function test_logistic_regression_no_data (line 88) | fn test_logistic_regression_no_data() {

FILE: src/machine_learning/loss_function/average_margin_ranking_loss.rs
  function average_margin_ranking_loss (line 22) | pub fn average_margin_ranking_loss(
  function check_input (line 38) | fn check_input(
  type MarginalRankingLossError (line 61) | pub enum MarginalRankingLossError {

FILE: src/machine_learning/loss_function/hinge_loss.rs
  function hng_loss (line 16) | pub fn hng_loss(y_true: &[f64], y_pred: &[f64]) -> f64 {
  function test_hinge_loss (line 30) | fn test_hinge_loss() {

FILE: src/machine_learning/loss_function/huber_loss.rs
  function huber_loss (line 12) | pub fn huber_loss(y_true: &[f64], y_pred: &[f64], delta: f64) -> Option<...

FILE: src/machine_learning/loss_function/kl_divergence_loss.rs
  function kld_loss (line 13) | pub fn kld_loss(actual: &[f64], predicted: &[f64]) -> f64 {
  function test_kld_loss (line 29) | fn test_kld_loss() {

FILE: src/machine_learning/loss_function/mean_absolute_error_loss.rs
  function mae_loss (line 16) | pub fn mae_loss(predicted: &[f64], actual: &[f64]) -> f64 {
  function test_mae_loss (line 31) | fn test_mae_loss() {

FILE: src/machine_learning/loss_function/mean_squared_error_loss.rs
  function mse_loss (line 16) | pub fn mse_loss(predicted: &[f64], actual: &[f64]) -> f64 {
  function test_mse_loss (line 30) | fn test_mse_loss() {

FILE: src/machine_learning/loss_function/negative_log_likelihood.rs
  function neg_log_likelihood (line 21) | pub fn neg_log_likelihood(
  type NegativeLogLikelihoodLossError (line 47) | pub enum NegativeLogLikelihoodLossError {
  function are_all_values_in_range (line 53) | fn are_all_values_in_range(values: &[f64]) -> bool {

FILE: src/machine_learning/naive_bayes.rs
  type ClassStatistics (line 7) | pub struct ClassStatistics {
  function calculate_class_statistics (line 14) | fn calculate_class_statistics(
  function gaussian_log_pdf (line 70) | fn gaussian_log_pdf(x: f64, mean: f64, variance: f64) -> f64 {
  function train_naive_bayes (line 77) | pub fn train_naive_bayes(training_data: Vec<(Vec<f64>, f64)>) -> Option<...
  function predict_naive_bayes (line 124) | pub fn predict_naive_bayes(model: &[ClassStatistics], test_point: &[f64]...
  function naive_bayes (line 159) | pub fn naive_bayes(training_data: Vec<(Vec<f64>, f64)>, test_point: Vec<...
  function test_naive_bayes_simple_classification (line 169) | fn test_naive_bayes_simple_classification() {
  function test_naive_bayes_one_dimensional (line 191) | fn test_naive_bayes_one_dimensional() {
  function test_naive_bayes_empty_training_data (line 211) | fn test_naive_bayes_empty_training_data() {
  function test_naive_bayes_empty_test_point (line 219) | fn test_naive_bayes_empty_test_point() {
  function test_naive_bayes_dimension_mismatch (line 227) | fn test_naive_bayes_dimension_mismatch() {
  function test_naive_bayes_inconsistent_feature_dimensions (line 235) | fn test_naive_bayes_inconsistent_feature_dimensions() {
  function test_naive_bayes_multiple_classes (line 246) | fn test_naive_bayes_multiple_classes() {
  function test_train_and_predict_separately (line 270) | fn test_train_and_predict_separately() {

FILE: src/machine_learning/optimization/adam.rs
  type Adam (line 41) | pub struct Adam {
    method new (line 51) | pub fn new(
    method step (line 67) | pub fn step(&mut self, gradients: &[f64]) -> Vec<f64> {
  function test_adam_init_default_values (line 92) | fn test_adam_init_default_values() {
  function test_adam_init_custom_lr_value (line 104) | fn test_adam_init_custom_lr_value() {
  function test_adam_init_custom_betas_value (line 116) | fn test_adam_init_custom_betas_value() {
  function test_adam_init_custom_epsilon_value (line 128) | fn test_adam_init_custom_epsilon_value() {
  function test_adam_init_all_custom_values (line 140) | fn test_adam_init_all_custom_values() {
  function test_adam_step_default_params (line 152) | fn test_adam_step_default_params() {
  function test_adam_step_custom_params (line 174) | fn test_adam_step_custom_params() {
  function test_adam_step_empty_gradients_array (line 197) | fn test_adam_step_empty_gradients_array() {
  function test_adam_step_iteratively_until_convergence_with_default_params (line 208) | fn test_adam_step_iteratively_until_convergence_with_default_params() {
  function test_adam_step_iteratively_until_convergence_with_custom_params (line 249) | fn test_adam_step_iteratively_until_convergence_with_custom_params() {

FILE: src/machine_learning/optimization/gradient_descent.rs
  function gradient_descent (line 25) | pub fn gradient_descent(
  function test_gradient_descent_optimized (line 46) | fn test_gradient_descent_optimized() {
  function test_gradient_descent_unoptimized (line 67) | fn test_gradient_descent_unoptimized() {

FILE: src/machine_learning/optimization/momentum.rs
  function momentum (line 29) | pub fn momentum(
  function test_momentum_optimized (line 56) | fn test_momentum_optimized() {
  function test_momentum_unoptimized (line 83) | fn test_momentum_unoptimized() {
  function test_momentum_faster_than_gd (line 110) | fn test_momentum_faster_than_gd() {

FILE: src/machine_learning/perceptron.rs
  function perceptron (line 4) | pub fn perceptron(
  function predict (line 46) | fn predict(weights: &[f64], bias: f64, features: &[f64]) -> f64 {
  function classify (line 62) | pub fn classify(weights: &[f64], bias: f64, features: &[f64]) -> Option<...
  function test_perceptron_linearly_separable (line 79) | fn test_perceptron_linearly_separable() {
  function test_perceptron_xor_like (line 102) | fn test_perceptron_xor_like() {
  function test_perceptron_single_feature (line 118) | fn test_perceptron_single_feature() {
  function test_perceptron_empty_data (line 142) | fn test_perceptron_empty_data() {
  function test_perceptron_empty_features (line 148) | fn test_perceptron_empty_features() {
  function test_perceptron_zero_iterations (line 155) | fn test_perceptron_zero_iterations() {
  function test_classify_empty_weights (line 167) | fn test_classify_empty_weights() {
  function test_classify_empty_features (line 173) | fn test_classify_empty_features() {
  function test_classify_mismatched_dimensions (line 179) | fn test_classify_mismatched_dimensions() {
  function test_perceptron_different_learning_rates (line 185) | fn test_perceptron_different_learning_rates() {
  function test_perceptron_with_bias (line 210) | fn test_perceptron_with_bias() {

FILE: src/machine_learning/principal_component_analysis.rs
  function compute_means (line 7) | fn compute_means(data: &[Vec<f64>]) -> Vec<f64> {
  function center_data (line 30) | fn center_data(data: &[Vec<f64>], means: &[f64]) -> Vec<Vec<f64>> {
  function compute_covariance_matrix (line 43) | fn compute_covariance_matrix(centered_data: &[Vec<f64>]) -> Vec<f64> {
  function power_iteration (line 70) | fn power_iteration(matrix: &[f64], n: usize, max_iter: usize, tolerance:...
  function deflate_matrix (line 121) | fn deflate_matrix(matrix: &[f64], eigenvector: &[f64], eigenvalue: f64, ...
  function principal_component_analysis (line 135) | pub fn principal_component_analysis(
  function test_pca_simple (line 199) | fn test_pca_simple() {
  function test_pca_empty_data (line 222) | fn test_pca_empty_data() {
  function test_pca_empty_features (line 229) | fn test_pca_empty_features() {
  function test_pca_invalid_num_components (line 236) | fn test_pca_invalid_num_components() {
  function test_pca_preserves_dimensions (line 247) | fn test_pca_preserves_dimensions() {
  function test_pca_reconstruction_variance (line 263) | fn test_pca_reconstruction_variance() {
  function test_center_data (line 286) | fn test_center_data() {
  function test_compute_means (line 302) | fn test_compute_means() {
  function test_power_iteration (line 314) | fn test_power_iteration() {

FILE: src/machine_learning/random_forest.rs
  function train_tree (line 6) | fn train_tree(
  type RandomForest (line 52) | pub struct RandomForest {
    method fit (line 59) | pub fn fit(
    method predict (line 134) | pub fn predict(&self, test_point: &[f64]) -> Option<f64> {
    method predict_batch (line 186) | pub fn predict_batch(&self, test_points: &[Vec<f64>]) -> Vec<Option<f6...
  function random_forest (line 195) | pub fn random_forest(
  function test_random_forest_linearly_separable (line 218) | fn test_random_forest_linearly_separable() {
  function test_random_forest_xor (line 238) | fn test_random_forest_xor() {
  function test_random_forest_multiple_classes (line 265) | fn test_random_forest_multiple_classes() {
  function test_random_forest_one_feature (line 286) | fn test_random_forest_one_feature() {
  function test_random_forest_empty_training_data (line 306) | fn test_random_forest_empty_training_data() {
  function test_random_forest_empty_features (line 313) | fn test_random_forest_empty_features() {
  function test_random_forest_predict_batch (line 320) | fn test_random_forest_predict_batch() {
  function test_random_forest_custom_max_features (line 342) | fn test_random_forest_custom_max_features() {
  function test_random_forest_convenience_function (line 360) | fn test_random_forest_convenience_function() {
  function test_random_forest_single_tree (line 383) | fn test_random_forest_single_tree() {
  function test_random_forest_empty_test_point (line 406) | fn test_random_forest_empty_test_point() {
  function test_random_forest_different_num_trees (line 424) | fn test_random_forest_different_num_trees() {

FILE: src/machine_learning/support_vector_classifier.rs
  type Kernel (line 31) | pub enum Kernel {
  type SVC (line 43) | pub struct SVC {
    method new (line 93) | pub fn new(kernel: Kernel, regularization: f64) -> Result<Self, SVCErr...
    method kernel_function (line 115) | fn kernel_function(&self, v1: &Array1<f64>, v2: &Array1<f64>) -> f64 {
    method fit (line 145) | pub fn fit(
    method solve_dual (line 179) | fn solve_dual(&self, n: usize) -> Array1<f64> {
    method calculate_offset (line 256) | fn calculate_offset(&self, n: usize) -> f64 {
    method predict (line 313) | pub fn predict(&self, observation: &Array1<f64>) -> f64 {
    method n_support_vectors (line 331) | pub fn n_support_vectors(&self) -> usize {
  type SVCError (line 54) | pub enum SVCError {
    method fmt (line 62) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  function test_linear_kernel_simple (line 342) | fn test_linear_kernel_simple() {
  function test_rbf_kernel (line 360) | fn test_rbf_kernel() {
  function test_invalid_gamma (line 378) | fn test_invalid_gamma() {
  function test_invalid_regularization (line 387) | fn test_invalid_regularization() {
  function test_empty_data (line 396) | fn test_empty_data() {
  function test_mismatched_dimensions (line 403) | fn test_mismatched_dimensions() {
  function test_support_vectors_count (line 412) | fn test_support_vectors_count() {

FILE: src/math/abs.rs
  function abs (line 5) | pub fn abs<T>(num: T) -> T
  function test_negative_number_i32 (line 20) | fn test_negative_number_i32() {
  function test_negative_number_f64 (line 25) | fn test_negative_number_f64() {
  function zero (line 30) | fn zero() {
  function positive_number (line 35) | fn positive_number() {

FILE: src/math/aliquot_sum.rs
  function aliquot_sum (line 9) | pub fn aliquot_sum(number: u64) -> u64 {
  function panics_if_input_is_zero (line 53) | fn panics_if_input_is_zero() {

FILE: src/math/amicable_numbers.rs
  function amicable_pairs_under_n (line 7) | pub fn amicable_pairs_under_n(n: u32) -> Option<Vec<(u32, u32)>> {
  function test_amicable_numbers_below_n (line 40) | pub fn test_amicable_numbers_below_n() {

FILE: src/math/area_of_polygon.rs
  type Point (line 17) | pub struct Point {
  function area_of_polygon (line 28) | pub fn area_of_polygon(fig: &[Point]) -> f64 {
  function test_area_triangle (line 53) | fn test_area_triangle() {
  function test_area_square (line 67) | fn test_area_square() {
  function test_area_hexagon (line 82) | fn test_area_hexagon() {

FILE: src/math/area_under_curve.rs
  function area_under_curve (line 1) | pub fn area_under_curve(start: f64, end: f64, func: fn(f64) -> f64, step...
  function test_linear_func (line 29) | fn test_linear_func() {
  function test_quadratic_func (line 34) | fn test_quadratic_func() {
  function test_zero_length (line 42) | fn test_zero_length() {
  function test_reverse (line 47) | fn test_reverse() {

FILE: src/math/armstrong_number.rs
  function is_armstrong_number (line 1) | pub fn is_armstrong_number(number: u32) -> bool {
  function one_digit_armstrong_number (line 25) | fn one_digit_armstrong_number() {
  function two_digit_numbers_are_not_armstrong_numbers (line 29) | fn two_digit_numbers_are_not_armstrong_numbers() {
  function three_digit_armstrong_number (line 33) | fn three_digit_armstrong_number() {
  function three_digit_non_armstrong_number (line 37) | fn three_digit_non_armstrong_number() {
  function big_armstrong_number (line 41) | fn big_armstrong_number() {

FILE: src/math/average.rs
  function sum (line 17) | fn sum<T: Num + Copy>(sequence: Vec<T>) -> T {
  function mean (line 25) | pub fn mean<T: Num + Copy + num_traits::FromPrimitive>(sequence: Vec<T>)...
  function mean_of_two (line 33) | fn mean_of_two<T: Num + Copy>(a: T, b: T) -> T {
  function median (line 42) | pub fn median<T: Num + Copy + PartialOrd>(mut sequence: Vec<T>) -> Optio...
  function histogram (line 56) | fn histogram<T: Eq + std::hash::Hash>(sequence: Vec<T>) -> HashMap<T, us...
  function mode (line 67) | pub fn mode<T: Eq + std::hash::Hash>(sequence: Vec<T>) -> Option<HashSet...
  function median_test (line 85) | fn median_test() {
  function mode_test (line 95) | fn mode_test() {
  function mean_test (line 111) | fn mean_test() {

FILE: src/math/baby_step_giant_step.rs
  function baby_step_giant_step (line 13) | pub fn baby_step_giant_step(a: usize, b: usize, n: usize) -> Option<usiz...
  function small_numbers (line 42) | fn small_numbers() {
  function primitive_root_tests (line 51) | fn primitive_root_tests() {
  function random_numbers (line 63) | fn random_numbers() {
  function no_solution (line 78) | fn no_solution() {

FILE: src/math/bell_numbers.rs
  function n_choose_r (line 6) | fn n_choose_r(n: u32, r: u32) -> BigUint {
  type MemTable (line 26) | struct MemTable {
    method new (line 31) | const fn new() -> Self {
    method get (line 35) | fn get(&self, n: usize) -> Option<BigUint> {
    method set (line 49) | fn set(&mut self, n: usize, b: BigUint) {
    method capacity (line 54) | fn capacity(&self) -> usize {
    method resize (line 59) | fn resize(&mut self, new_size: usize) {
  function bell_number (line 69) | pub fn bell_number(n: u32) -> BigUint {
  function test_choose_zero (line 109) | fn test_choose_zero() {
  function test_combination (line 116) | fn test_combination() {
  function test_bell_numbers (line 131) | fn test_bell_numbers() {

FILE: src/math/binary_exponentiation.rs
  function binary_exponentiation (line 13) | pub fn binary_exponentiation(mut n: u64, mut p: u32) -> u64 {
  function basic (line 30) | fn basic() {
  function up_to_ten (line 41) | fn up_to_ten() {

FILE: src/math/binomial_coefficient.rs
  function binom (line 26) | pub fn binom(n: u64, k: u64) -> BigInt {
  function test_binom_5_2 (line 39) | fn test_binom_5_2() {
  function test_binom_10_5 (line 44) | fn test_binom_10_5() {
  function test_binom_0_0 (line 49) | fn test_binom_0_0() {
  function test_binom_large_n_small_k (line 54) | fn test_binom_large_n_small_k() {
  function test_binom_random_1 (line 59) | fn test_binom_random_1() {
  function test_binom_random_2 (line 65) | fn test_binom_random_2() {
  function test_binom_random_3 (line 71) | fn test_binom_random_3() {

FILE: src/math/catalan_numbers.rs
  constant MOD (line 12) | const MOD: i64 = 1000000007;
  constant MAX (line 13) | const MAX: usize = 1005;
  function init_catalan (line 15) | pub fn init_catalan() -> Vec<i64> {
  function test_catalan (line 38) | fn test_catalan() {

FILE: src/math/ceil.rs
  function ceil (line 4) | pub fn ceil(x: f64) -> f64 {
  function positive_decimal (line 18) | fn positive_decimal() {
  function positive_decimal_with_small_number (line 24) | fn positive_decimal_with_small_number() {
  function positive_integer (line 30) | fn positive_integer() {
  function negative_decimal (line 36) | fn negative_decimal() {
  function negative_decimal_with_small_number (line 42) | fn negative_decimal_with_small_number() {
  function negative_integer (line 48) | fn negative_integer() {
  function zero (line 54) | fn zero() {

FILE: src/math/chinese_remainder_theorem.rs
  function mod_inv (line 3) | fn mod_inv(x: i32, n: i32) -> Option<i32> {
  function chinese_remainder_theorem (line 12) | pub fn chinese_remainder_theorem(residues: &[i32], modulli: &[i32]) -> O...
  function basic (line 29) | fn basic() {

FILE: src/math/collatz_sequence.rs
  function sequence (line 2) | pub fn sequence(mut n: usize) -> Option<Vec<usize>> {
  function validity_check (line 24) | fn validity_check() {

FILE: src/math/combinations.rs
  function combinations (line 2) | pub fn combinations(n: i64, k: i64) -> i64 {
  function test_combinations_10_choose_5 (line 25) | fn test_combinations_10_choose_5() {
  function test_combinations_6_choose_3 (line 31) | fn test_combinations_6_choose_3() {
  function test_combinations_20_choose_5 (line 37) | fn test_combinations_20_choose_5() {
  function test_combinations_invalid_input (line 44) | fn test_combinations_invalid_input() {

FILE: src/math/cross_entropy_loss.rs
  function cross_entropy_loss (line 19) | pub fn cross_entropy_loss(actual: &[f64], predicted: &[f64]) -> f64 {
  function test_cross_entropy_loss (line 32) | fn test_cross_entropy_loss() {

FILE: src/math/decimal_to_fraction.rs
  function decimal_to_fraction (line 1) | pub fn decimal_to_fraction(decimal: f64) -> (i64, i64) {
  function test_decimal_to_fraction_1 (line 39) | fn test_decimal_to_fraction_1() {
  function test_decimal_to_fraction_2 (line 44) | fn test_decimal_to_fraction_2() {
  function test_decimal_to_fraction_3 (line 49) | fn test_decimal_to_fraction_3() {
  function test_decimal_to_fraction_4 (line 54) | fn test_decimal_to_fraction_4() {
  function test_decimal_to_fraction_5 (line 59) | fn test_decimal_to_fraction_5() {
  function test_decimal_to_fraction_6 (line 64) | fn test_decimal_to_fraction_6() {

FILE: src/math/doomsday.rs
  constant T (line 1) | const T: [i32; 12] = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4];
  function doomsday (line 3) | pub fn doomsday(y: i32, m: i32, d: i32) -> i32 {
  function get_week_day (line 8) | pub fn get_week_day(y: i32, m: i32, d: i32) -> String {
  function doomsday_test (line 29) | fn doomsday_test() {

FILE: src/math/elliptic_curve.rs
  type EllipticCurve (line 27) | pub struct EllipticCurve<F, const A: i64, const B: i64> {
  function infinity (line 35) | pub fn infinity() -> Self {
  function new (line 48) | pub fn new(x: impl Into<F>, y: impl Into<F>) -> Option<Self> {
  function is_infinity (line 64) | pub fn is_infinity(&self) -> bool {
  function x (line 69) | pub fn x(&self) -> &F {
  function y (line 74) | pub fn y(&self) -> &F {
  function discriminant (line 79) | pub const fn discriminant() -> i64 {
  function contains (line 86) | fn contains(x: F, y: F) -> bool {
  function check_invariants (line 90) | const fn check_invariants() {
  function points (line 101) | pub fn points() -> impl Iterator<Item = Self> {
  function cardinality (line 109) | pub fn cardinality() -> usize {
  function cardinality_counted_table (line 123) | pub fn cardinality_counted_table() -> usize {
  function cardinality_counted_legendre (line 156) | pub fn cardinality_counted_legendre() -> usize {
  type Output (line 174) | type Output = Self;
  method add (line 176) | fn add(self, p: Self) -> Self::Output {
  type Output (line 199) | type Output = Self;
  method neg (line 201) | fn neg(self) -> Self::Output {
  type Output (line 212) | type Output = Self;
  method sub (line 214) | fn sub(self, p: Self) -> Self::Output {
  function fmt (line 221) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method eq (line 232) | fn eq(&self, other: &Self) -> bool {
  method hash (line 241) | fn hash<H: Hasher>(&self, state: &mut H) {
  function test_char_2_panic (line 263) | fn test_char_2_panic() {
  function test_char_3_panic (line 269) | fn test_char_3_panic() {
  function test_singular_panic (line 275) | fn test_singular_panic() {
  function e_5_1_0_group_table (line 280) | fn e_5_1_0_group_table() {
  function group_law (line 311) | fn group_law() {
  function cardinality (line 346) | fn cardinality() {
  function cardinality_perf (line 364) | fn cardinality_perf() {
  function cardinality_large_prime (line 379) | fn cardinality_large_prime() {
  function test_points (line 390) | fn test_points() {

FILE: src/math/euclidean_distance.rs
  function euclidean_distance (line 5) | pub fn euclidean_distance(vector_1: &Vector, vector_2: &Vector) -> f64 {
  type Vector (line 16) | type Vector = Vec<f64>;
  function test_euclidean_distance (line 24) | fn test_euclidean_distance() {

FILE: src/math/exponential_linear_unit.rs
  function exponential_linear_unit (line 27) | pub fn exponential_linear_unit(vector: &Vec<f64>, alpha: f64) -> Vec<f64> {
  function test_exponential_linear_unit (line 44) | fn test_exponential_linear_unit() {

FILE: src/math/extended_euclidean_algorithm.rs
  function update_step (line 1) | fn update_step(a: &mut i32, old_a: &mut i32, quotient: i32) {
  function extended_euclidean_algorithm (line 7) | pub fn extended_euclidean_algorithm(a: i32, b: i32) -> (i32, i32, i32) {
  function basic (line 28) | fn basic() {

FILE: src/math/factorial.rs
  function factorial (line 6) | pub fn factorial(number: u64) -> u64 {
  function factorial_recursive (line 16) | pub fn factorial_recursive(n: u64) -> u64 {
  function factorial_bigmath (line 26) | pub fn factorial_bigmath(num: u32) -> BigUint {
  function test_factorial (line 41) | fn test_factorial() {
  function test_factorial_recursive (line 51) | fn test_factorial_recursive() {
  function basic_factorial (line 60) | fn basic_factorial() {

FILE: src/math/factors.rs
  function factors (line 6) | pub fn factors(number: u64) -> Vec<u64> {
  function prime_number (line 27) | fn prime_number() {
  function highly_composite_number (line 32) | fn highly_composite_number() {
  function composite_number (line 43) | fn composite_number() {

FILE: src/math/fast_fourier_transform.rs
  type Complex64 (line 5) | pub struct Complex64 {
    method new (line 12) | pub fn new(re: f64, im: f64) -> Self {
    method square_norm (line 17) | pub fn square_norm(&self) -> f64 {
    method norm (line 22) | pub fn norm(&self) -> f64 {
    method inverse (line 27) | pub fn inverse(&self) -> Complex64 {
    type Output (line 44) | type Output = Complex64;
    method add (line 47) | fn add(self, other: Complex64) -> Complex64 {
    type Output (line 56) | type Output = Complex64;
    method sub (line 59) | fn sub(self, other: Complex64) -> Complex64 {
    type Output (line 68) | type Output = Complex64;
    method mul (line 71) | fn mul(self, other: Complex64) -> Complex64 {
    method mul_assign (line 81) | fn mul_assign(&mut self, other: Complex64) {
  method default (line 38) | fn default() -> Self {
  function fast_fourier_transform_input_permutation (line 88) | pub fn fast_fourier_transform_input_permutation(length: usize) -> Vec<us...
  function fast_fourier_transform (line 113) | pub fn fast_fourier_transform(input: &[f64], input_permutation: &[usize]...
  function inverse_fast_fourier_transform (line 139) | pub fn inverse_fast_fourier_transform(
  function almost_equal (line 172) | fn almost_equal(a: f64, b: f64, epsilon: f64) -> bool {
  constant EPSILON (line 176) | const EPSILON: f64 = 1e-6;
  function small_polynomial_returns_self (line 179) | fn small_polynomial_returns_self() {
  function square_small_polynomial (line 190) | fn square_small_polynomial() {
  function square_big_polynomial (line 207) | fn square_big_polynomial() {

FILE: src/math/fast_power.rs
  function fast_power (line 2) | pub fn fast_power(mut base: usize, mut power: usize, modulus: usize) -> ...
  function test (line 21) | fn test() {

FILE: src/math/faster_perfect_numbers.rs
  function generate_perfect_numbers (line 8) | pub fn generate_perfect_numbers(num: usize) -> Vec<usize> {
  function get_prime_limit (line 25) | fn get_prime_limit(num: usize) -> usize {
  function perfect_numbers_till_n (line 34) | fn perfect_numbers_till_n() {

FILE: src/math/field.rs
  type Field (line 8) | pub trait Field:
    constant CHARACTERISTIC (line 18) | const CHARACTERISTIC: u64;
    constant ZERO (line 19) | const ZERO: Self;
    constant ONE (line 20) | const ONE: Self;
    method inverse (line 23) | fn inverse(self) -> Self;
    method integer_mul (line 26) | fn integer_mul(self, a: i64) -> Self;
    method from_integer (line 27) | fn from_integer(a: i64) -> Self {
    method elements (line 35) | fn elements() -> Self::ElementsIter;
    constant CHARACTERISTIC (line 144) | const CHARACTERISTIC: u64 = P;
    constant ZERO (line 145) | const ZERO: Self = Self { a: 0 };
    constant ONE (line 146) | const ONE: Self = Self { a: 1 };
    method inverse (line 148) | fn inverse(self) -> Self {
    method integer_mul (line 158) | fn integer_mul(self, mut n: i64) -> Self {
    type ElementsIter (line 179) | type ElementsIter = PrimeFieldElementsIter<P>;
    method elements (line 181) | fn elements() -> Self::ElementsIter {
  type PrimeField (line 43) | pub struct PrimeField<const P: u64> {
  function reduce (line 49) | fn reduce(self) -> Self {
  function to_integer (line 58) | pub fn to_integer(&self) -> u64 {
  function from (line 64) | fn from(a: i64) -> Self {
  method eq (line 70) | fn eq(&self, other: &Self) -> bool {
  type Output (line 78) | type Output = Self;
  method neg (line 80) | fn neg(self) -> Self::Output {
  type Output (line 86) | type Output = Self;
  method add (line 88) | fn add(self, rhs: Self) -> Self::Output {
  type Output (line 100) | type Output = Self;
  method sub (line 102) | fn sub(self, rhs: Self) -> Self::Output {
  type Output (line 114) | type Output = Self;
  method mul (line 116) | fn mul(self, rhs: Self) -> Self::Output {
  type Output (line 128) | type Output = Self;
  method div (line 131) | fn div(self, rhs: Self) -> Self::Output {
  function fmt (line 137) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PrimeFieldElementsIter (line 187) | pub struct PrimeFieldElementsIter<const P: u64> {
  type Item (line 192) | type Item = PrimeField<P>;
  method next (line 194) | fn next(&mut self) -> Option<Self::Item> {
  method hash (line 206) | fn hash<H: Hasher>(&self, state: &mut H) {
  function mod_inverse (line 213) | fn mod_inverse(mut a: i64, mut b: i64) -> i64 {
  function test_field_elements (line 233) | fn test_field_elements() {
  function large_prime_field (line 260) | fn large_prime_field() {
  function inverse (line 269) | fn inverse() {
  function test_mod_inverse (line 298) | fn test_mod_inverse() {
  function integer_mul (line 314) | fn integer_mul() {
  function from_integer (line 325) | fn from_integer() {

FILE: src/math/frizzy_number.rs
  function get_nth_frizzy (line 24) | pub fn get_nth_frizzy(base: i32, mut n: i32) -> f64 {
  function test_get_nth_frizzy (line 40) | fn test_get_nth_frizzy() {

FILE: src/math/gaussian_elimination.rs
  function gaussian_elimination (line 6) | pub fn gaussian_elimination(matrix: &mut [Vec<f32>]) -> Vec<f32> {
  function echelon (line 36) | fn echelon(matrix: &mut [Vec<f32>], i: usize, j: usize) {
  function eliminate (line 47) | fn eliminate(matrix: &mut [Vec<f32>], i: usize) {
  function test_gauss (line 65) | fn test_gauss() {

FILE: src/math/gaussian_error_linear_unit.rs
  function tanh (line 23) | fn tanh(vector: f64) -> f64 {
  function gaussian_error_linear_unit (line 27) | pub fn gaussian_error_linear_unit(vector: &Vec<f64>) -> Vec<f64> {
  function test_gaussian_error_linear_unit (line 43) | fn test_gaussian_error_linear_unit() {

FILE: src/math/gcd_of_n_numbers.rs
  function gcd (line 2) | pub fn gcd(nums: &[usize]) -> usize {
  function gcd_of_two_numbers (line 11) | fn gcd_of_two_numbers(a: usize, b: usize) -> usize {
  function it_works (line 22) | fn it_works() {

FILE: src/math/geometric_series.rs
  function geometric_series (line 5) | pub fn geometric_series(nth_term: f64, start_term_a: f64, common_ratio_r...
  function assert_approx_eq (line 21) | fn assert_approx_eq(a: f64, b: f64) {
  function test_geometric_series (line 27) | fn test_geometric_series() {

FILE: src/math/greatest_common_divisor.rs
  function greatest_common_divisor_recursive (line 9) | pub fn greatest_common_divisor_recursive(a: i64, b: i64) -> i64 {
  function greatest_common_divisor_iterative (line 17) | pub fn greatest_common_divisor_iterative(mut a: i64, mut b: i64) -> i64 {
  function greatest_common_divisor_stein (line 26) | pub fn greatest_common_divisor_stein(a: u64, b: u64) -> u64 {
  function positive_number_recursive (line 53) | fn positive_number_recursive() {
  function positive_number_iterative (line 62) | fn positive_number_iterative() {
  function positive_number_stein (line 71) | fn positive_number_stein() {
  function negative_number_recursive (line 80) | fn negative_number_recursive() {
  function negative_number_iterative (line 89) | fn negative_number_iterative() {
  function mix_recursive (line 98) | fn mix_recursive() {
  function mix_iterative (line 108) | fn mix_iterative() {

FILE: src/math/huber_loss.rs
  function huber_loss (line 20) | pub fn huber_loss(actual: &[f64], predicted: &[f64], delta: f64) -> f64 {
  function test_huber_loss (line 38) | fn test_huber_loss() {

FILE: src/math/infix_to_postfix.rs
  type InfixToPostfixError (line 2) | pub enum InfixToPostfixError {
  function infix_to_postfix (line 8) | pub fn infix_to_postfix(infix: &str) -> Result<String, InfixToPostfixErr...

FILE: src/math/interest.rs
  function simple_interest (line 5) | pub fn simple_interest(principal: f64, annual_rate: f64, years: f64) -> ...
  function compound_interest (line 16) | pub fn compound_interest(principal: f64, annual_rate: f64, years: f64, p...
  function test_simple (line 37) | fn test_simple() {
  function test_compounding (line 43) | fn test_compounding() {

FILE: src/math/interpolation.rs
  function linear_interpolation (line 6) | pub fn linear_interpolation(x: f64, point0: (f64, f64), point1: (f64, f6...
  function lagrange_polynomial_interpolation (line 17) | pub fn lagrange_polynomial_interpolation(x: f64, defined_points: &Vec<(f...
  function test_linear_intepolation (line 51) | fn test_linear_intepolation() {
  function test_lagrange_polynomial_interpolation (line 71) | fn test_lagrange_polynomial_interpolation() {

FILE: src/math/interquartile_range.rs
  function find_median (line 8) | pub fn find_median(numbers: &[f64]) -> f64 {
  function interquartile_range (line 22) | pub fn interquartile_range(numbers: &[f64]) -> f64 {
  function test_find_median (line 50) | fn test_find_median() {
  function test_interquartile_range (line 65) | fn test_interquartile_range() {
  function test_interquartile_range_empty_list (line 81) | fn test_interquartile_range_empty_list() {

FILE: src/math/karatsuba_multiplication.rs
  constant TEN (line 5) | const TEN: i128 = 10;
  function multiply (line 7) | pub fn multiply(num1: i128, num2: i128) -> i128 {
  function _multiply (line 11) | fn _multiply(num1: i128, num2: i128) -> i128 {
  function normalize (line 37) | fn normalize(mut a: String, n: usize) -> String {
  function test_1 (line 47) | fn test_1() {
  function test_2 (line 55) | fn test_2() {
  function test_3 (line 63) | fn test_3() {

FILE: src/math/lcm_of_n_numbers.rs
  function lcm (line 3) | pub fn lcm(nums: &[usize]) -> usize {
  function gcd_of_two_numbers (line 12) | fn gcd_of_two_numbers(a: usize, b: usize) -> usize {
  function it_works (line 23) | fn it_works() {

FILE: src/math/leaky_relu.rs
  function leaky_relu (line 22) | pub fn leaky_relu(vector: &Vec<f64>, alpha: f64) -> Vec<f64> {
  function test_leaky_relu (line 39) | fn test_leaky_relu() {

FILE: src/math/least_square_approx.rs
  function least_square_approx (line 12) | pub fn least_square_approx<T: Into<f64> + Copy, U: Into<f64> + Copy>(
  function ten_points_1st_degree (line 63) | fn ten_points_1st_degree() {
  function eight_points_5th_degree (line 84) | fn eight_points_5th_degree() {
  function four_points_2nd_degree (line 105) | fn four_points_2nd_degree() {

FILE: src/math/linear_sieve.rs
  type LinearSieve (line 11) | pub struct LinearSieve {
    method new (line 18) | pub const fn new() -> Self {
    method prepare (line 26) | pub fn prepare(&mut self, max_number: usize) -> Result<(), &'static st...
    method factorize (line 63) | pub fn factorize(&self, mut number: usize) -> Result<Vec<usize>, &'sta...
  method default (line 80) | fn default() -> Self {
  function small_primes_list (line 90) | fn small_primes_list() {
  function divisible_by_mpf (line 97) | fn divisible_by_mpf() {
  function check_factorization (line 111) | fn check_factorization() {
  function check_number_of_primes (line 129) | fn check_number_of_primes() {

FILE: src/math/logarithm.rs
  function log (line 11) | pub fn log<T: Into<f64>, U: Into<f64>>(base: U, x: T, tol: f64) -> f64 {
  function basic (line 50) | fn basic() {
  function test_log_positive_base (line 58) | fn test_log_positive_base() {
  function test_log_zero_base (line 64) | fn test_log_zero_base() {
  function test_log_negative_base (line 69) | fn test_log_negative_base() {
  function test_log_tolerance (line 74) | fn test_log_tolerance() {

FILE: src/math/lucas_series.rs
  function recursive_lucas_number (line 6) | pub fn recursive_lucas_number(n: u32) -> u32 {
  function dynamic_lucas_number (line 14) | pub fn dynamic_lucas_number(n: u32) -> u32 {

FILE: src/math/matrix_ops.rs
  type MatrixElement (line 17) | pub trait MatrixElement:
  type Matrix (line 50) | pub struct Matrix<T: MatrixElement> {
  function new (line 57) | pub fn new(data: Vec<T>, rows: usize, cols: usize) -> Self {
  function zero (line 65) | pub fn zero(rows: usize, cols: usize) -> Self {
  function identity (line 74) | pub fn identity(len: usize) -> Self {
  function transpose (line 84) | pub fn transpose(&self) -> Self {
  type Output (line 97) | type Output = T;
  function index (line 99) | fn index(&self, index: [usize; 2]) -> &Self::Output {
  function index_mut (line 110) | fn index_mut(&mut self, index: [usize; 2]) -> &mut Self::Output {
  type Output (line 121) | type Output = Matrix<T>;
  function add (line 123) | fn add(self, rhs: &Matrix<T>) -> Self::Output {
  type Output (line 140) | type Output = Matrix<T>;
  method sub (line 142) | fn sub(self, rhs: Self) -> Self::Output {
  type Output (line 159) | type Output = Matrix<T>;
  method mul (line 161) | fn mul(self, rhs: Self) -> Self::Output {
  type Output (line 185) | type Output = Matrix<T>;
  function mul (line 187) | fn mul(self, rhs: T) -> Self::Output {
  function from (line 200) | fn from(v: Vec<Vec<T>>) -> Self {
  constant DELTA (line 226) | const DELTA: f64 = 1e-3;
  function test_invalid_matrix (line 243) | fn test_invalid_matrix() {
  function test_empty_matrix (line 253) | fn test_empty_matrix() {
  function test_zero_matrix (line 261) | fn test_zero_matrix() {
  function test_identity_matrix (line 274) | fn test_identity_matrix() {
  function test_invalid_add (line 289) | fn test_invalid_add() {
  function test_add_i32 (line 306) | fn test_add_i32() {
  function test_add_f64 (line 329) | fn test_add_f64() {
  function test_invalid_sub (line 352) | fn test_invalid_sub() {
  function test_subtract_i32 (line 369) | fn test_subtract_i32() {
  function test_subtract_f64 (line 392) | fn test_subtract_f64() {
  function test_invalid_mul (line 415) | fn test_invalid_mul() {
  function test_mul_i32 (line 435) | fn test_mul_i32() {
  function test_mul_f64 (line 460) | fn test_mul_f64() {
  function test_transpose_i32 (line 484) | fn test_transpose_i32() {
  function test_transpose_f64 (line 501) | fn test_transpose_f64() {
  function test_matrix_scalar_zero_mul (line 518) | fn test_matrix_scalar_zero_mul() {
  function test_matrix_scalar_mul_i32 (line 533) | fn test_matrix_scalar_mul_i32() {
  function test_matrix_scalar_mul_f64 (line 552) | fn test_matrix_scalar_mul_f64() {

FILE: src/math/mersenne_primes.rs
  function is_mersenne_prime (line 2) | pub fn is_mersenne_prime(n: usize) -> bool {
  function get_mersenne_primes (line 14) | pub fn get_mersenne_primes(limit: usize) -> Vec<usize> {
  function validity_check (line 29) | fn validity_check() {
  function generation_check (line 36) | fn generation_check() {

FILE: src/math/miller_rabin.rs
  function modulo_power (line 5) | fn modulo_power(mut base: u64, mut power: u64, modulo: u64) -> u64 {
  function check_prime_base (line 22) | fn check_prime_base(number: u64, base: u64, two_power: u64, odd_power: u...
  function miller_rabin (line 38) | pub fn miller_rabin(number: u64, bases: &[u64]) -> u64 {
  function big_miller_rabin (line 67) | pub fn big_miller_rabin(number_ref: &BigUint, bases: &[u64]) -> u64 {
  function basic (line 124) | fn basic() {
  function big_basic (line 161) | fn big_basic() {
  function big_primes (line 214) | fn big_primes() {

FILE: src/math/modular_exponential.rs
  function gcd_extended (line 14) | pub fn gcd_extended(a: i64, m: i64) -> (i64, i64, i64) {
  function mod_inverse (line 38) | pub fn mod_inverse(b: i64, m: i64) -> i64 {
  function modular_exponential (line 60) | pub fn modular_exponential(base: i64, mut power: i64, modulus: i64) -> i...
  function test_modular_exponential_positive (line 91) | fn test_modular_exponential_positive() {
  function test_modular_inverse (line 100) | fn test_modular_inverse() {
  function test_modular_exponential_negative (line 109) | fn test_modular_exponential_negative() {
  function test_modular_exponential_edge_cases (line 129) | fn test_modular_exponential_edge_cases() {

FILE: src/math/newton_raphson.rs
  function find_root (line 1) | pub fn find_root(f: fn(f64) -> f64, fd: fn(f64) -> f64, guess: f64, iter...
  function iteration (line 9) | pub fn iteration(f: fn(f64) -> f64, fd: fn(f64) -> f64, guess: f64) -> f...
  function math_fn (line 17) | fn math_fn(x: f64) -> f64 {
  function math_fnd (line 20) | fn math_fnd(x: f64) -> f64 {
  function basic (line 24) | fn basic() {

FILE: src/math/nthprime.rs
  function nthprime (line 3) | pub fn nthprime(nth: u64) -> u64 {
  function get_primes (line 23) | fn get_primes(s: u64) -> Vec<u64> {
  function count_prime (line 40) | fn count_prime(primes: Vec<u64>, n: u64) -> Option<u64> {
  function my_test (line 55) | fn my_test() {

FILE: src/math/pascal_triangle.rs
  function pascal_triangle (line 12) | pub fn pascal_triangle(num_rows: i32) -> Vec<Vec<i32>> {
  function test (line 35) | fn test() {

FILE: src/math/perfect_cube.rs
  function perfect_cube_binary_search (line 2) | pub fn perfect_cube_binary_search(n: i64) -> bool {

FILE: src/math/perfect_numbers.rs
  function is_perfect_number (line 1) | pub fn is_perfect_number(num: usize) -> bool {
  function perfect_numbers (line 13) | pub fn perfect_numbers(max: usize) -> Vec<usize> {
  function basic (line 31) | fn basic() {

FILE: src/math/perfect_square.rs
  function perfect_square (line 4) | pub fn perfect_square(num: i32) -> bool {
  function perfect_square_binary_search (line 12) | pub fn perfect_square_binary_search(n: i32) -> bool {
  function test_perfect_square (line 39) | fn test_perfect_square() {
  function test_perfect_square_binary_search (line 49) | fn test_perfect_square_binary_search() {

FILE: src/math/pollard_rho.rs
  type LinearCongruenceGenerator (line 3) | struct LinearCongruenceGenerator {
    method new (line 11) | fn new(multiplier: u32, increment: u32, state: u32) -> Self {
    method next (line 18) | fn next(&mut self) -> u32 {
    method get_64bits (line 22) | fn get_64bits(&mut self) -> u64 {
  function gcd (line 27) | fn gcd(mut a: u64, mut b: u64) -> u64 {
  function advance (line 37) | fn advance(x: u128, c: u64, number: u64) -> u128 {
  function pollard_rho_customizable (line 41) | fn pollard_rho_customizable(
  function pollard_rho_get_one_factor (line 104) | pub fn pollard_rho_get_one_factor(number: u64, seed: &mut u32, check_is_...
  function get_small_factors (line 137) | fn get_small_factors(mut number: u64, primes: &[usize]) -> (u64, Vec<u64...
  function factor_using_mpf (line 148) | fn factor_using_mpf(mut number: usize, mpf: &[usize]) -> Vec<u64> {
  function pollard_rho_factorize (line 161) | pub fn pollard_rho_factorize(
  function check_is_proper_factor (line 203) | fn check_is_proper_factor(number: u64, factor: u64) -> bool {
  function check_factorization (line 207) | fn check_factorization(number: u64, factors: &[u64]) -> bool {
  function one_factor (line 219) | fn one_factor() {
  function big_numbers (line 250) | fn big_numbers() {

FILE: src/math/postfix_evaluation.rs
  type PostfixError (line 9) | pub enum PostfixError {
  function evaluate_postfix (line 34) | pub fn evaluate_postfix(expression: &str) -> Result<isize, PostfixError> {

FILE: src/math/prime_check.rs
  function prime_check (line 1) | pub fn prime_check(num: usize) -> bool {
  function basic (line 22) | fn basic() {

FILE: src/math/prime_factors.rs
  function prime_factors (line 3) | pub fn prime_factors(n: u64) -> Vec<u64> {
  function it_works (line 28) | fn it_works() {

FILE: src/math/prime_numbers.rs
  function prime_numbers (line 1) | pub fn prime_numbers(max: usize) -> Vec<usize> {
  function basic (line 30) | fn basic() {

FILE: src/math/quadratic_residue.rs
  type CustomFiniteField (line 18) | struct CustomFiniteField {
    method new (line 24) | pub fn new(modulus: u64, i_square: u64) -> Self {
  type CustomComplexNumber (line 30) | struct CustomComplexNumber {
    method new (line 37) | pub fn new(real: u64, imag: u64, f: Rc<CustomFiniteField>) -> Self {
    method mult_other (line 41) | pub fn mult_other(&mut self, rhs: &Self) {
    method mult_self (line 49) | pub fn mult_self(&mut self) {
    method fast_power (line 57) | pub fn fast_power(mut base: Self, mut power: u64) -> Self {
  function is_residue (line 70) | fn is_residue(x: u64, modulus: u64) -> bool {
  function legendre_symbol (line 80) | pub fn legendre_symbol(a: u64, odd_prime: u64) -> i64 {
  function cipolla (line 93) | pub fn cipolla(a: u32, p: u32, seed: Option<u64>) -> Option<(u32, u32)> {
  function tonelli_shanks (line 141) | pub fn tonelli_shanks(a: i64, odd_prime: u64) -> Option<u64> {
  function tonelli_shanks_residues (line 198) | fn tonelli_shanks_residues(x: u64, odd_prime: u64) -> Option<(u64, u64)> {
  function cipolla_small_numbers (line 205) | fn cipolla_small_numbers() {
  function tonelli_shanks_small_numbers (line 212) | fn tonelli_shanks_small_numbers() {
  function cipolla_random_numbers (line 219) | fn cipolla_random_numbers() {
  function tonelli_shanks_random_numbers (line 240) | fn tonelli_shanks_random_numbers() {
  function no_answer (line 264) | fn no_answer() {

FILE: src/math/random.rs
  type PCG32 (line 9) | pub struct PCG32 {
    method new (line 24) | pub fn new(seed: u64, multiplier: u64, stream: u64) -> Self {
    method new_default (line 35) | pub fn new_default(seed: u64) -> Self {
    method next (line 47) | pub fn next(&mut self) {
    method advance (line 56) | pub fn advance(&mut self, mut delta: u64) {
    method get_u32 (line 73) | pub fn get_u32(&mut self) -> u32 {
    method get_u64 (line 83) | pub fn get_u64(&mut self) -> u64 {
    method get_u16 (line 87) | pub fn get_u16(&mut self) -> (u16, u16) {
    method get_u8 (line 92) | pub fn get_u8(&mut self) -> (u8, u8, u8, u8) {
    method get_state (line 102) | pub fn get_state(&self) -> u64 {
    method iter_mut (line 105) | pub fn iter_mut(&mut self) -> IterMut<'_> {
  constant PCG32_MULTIPLIER (line 15) | pub const PCG32_MULTIPLIER: u64 = 6364136223846793005_u64;
  constant PCG32_INCREMENT (line 16) | pub const PCG32_INCREMENT: u64 = 1442695040888963407_u64;
  type IterMut (line 18) | pub struct IterMut<'a> {
  type Item (line 111) | type Item = u32;
  method next (line 112) | fn next(&mut self) -> Option<Self::Item> {
  function no_birthday (line 122) | fn no_birthday() {

FILE: src/math/relu.rs
  function relu (line 11) | pub fn relu(array: &mut Vec<f32>) -> &mut Vec<f32> {
  function test_relu (line 27) | fn test_relu() {

FILE: src/math/sieve_of_eratosthenes.rs
  function sieve_of_eratosthenes (line 10) | pub fn sieve_of_eratosthenes(num: usize) -> Vec<usize> {
  function update_sieve (line 38) | fn update_sieve(sieve: &mut [bool], end: usize, num: usize, result: &mut...
  function extract_remaining_primes (line 59) | fn extract_remaining_primes(sieve: &[bool], start: usize) -> Vec<usize> {
  constant PRIMES_UP_TO_997 (line 71) | const PRIMES_UP_TO_997: [usize; 168] = [

FILE: src/math/sigmoid.rs
  function sigmoid (line 13) | pub fn sigmoid(array: &mut Vec<f32>) -> &mut Vec<f32> {
  function test_sigmoid (line 27) | fn test_sigmoid() {

FILE: src/math/signum.rs
  function signum (line 8) | pub fn signum(number: f64) -> i8 {
  function positive_integer (line 23) | fn positive_integer() {
  function negative_integer (line 28) | fn negative_integer() {
  function zero (line 33) | fn zero() {

FILE: src/math/simpsons_integration.rs
  function simpsons_integration (line 1) | pub fn simpsons_integration<F>(f: F, a: f64, b: f64, n: usize) -> f64
  function test_simpsons_integration (line 21) | fn test_simpsons_integration() {
  function test_error (line 31) | fn test_error() {
  function test_convergence (line 42) | fn test_convergence() {
  function test_negative (line 57) | fn test_negative() {
  function test_non_zero_lower_bound (line 67) | fn test_non_zero_lower_bound() {
  function test_non_zero_upper_bound (line 77) | fn test_non_zero_upper_bound() {
  function test_non_zero_lower_and_upper_bound (line 87) | fn test_non_zero_lower_and_upper_bound() {
  function test_non_zero_lower_and_upper_bound_negative (line 97) | fn test_non_zero_lower_and_upper_bound_negative() {
  function parabola_curve_length (line 107) | fn parabola_curve_length() {
  function area_under_cosine (line 118) | fn area_under_cosine() {

FILE: src/math/softmax.rs
  function softmax (line 22) | pub fn softmax(array: Vec<f32>) -> Vec<f32> {
  function test_softmax (line 43) | fn test_softmax() {

FILE: src/math/sprague_grundy_theorem.rs
  function calculate_grundy_number (line 16) | pub fn calculate_grundy_number(
  function calculate_grundy_number_test (line 64) | fn calculate_grundy_number_test() {

FILE: src/math/square_pyramidal_numbers.rs
  function square_pyramidal_number (line 4) | pub fn square_pyramidal_number(n: u64) -> u64 {
  function test0 (line 14) | fn test0() {

FILE: src/math/square_root.rs
  function square_root (line 3) | pub fn square_root(num: f64) -> f64 {
  function fast_inv_sqrt (line 20) | pub fn fast_inv_sqrt(num: f32) -> f32 {
  function test_fast_inv_sqrt (line 41) | fn test_fast_inv_sqrt() {
  function test_sqare_root (line 53) | fn test_sqare_root() {

FILE: src/math/sum_of_digits.rs
  function sum_digits_iterative (line 15) | pub fn sum_digits_iterative(num: i32) -> u32 {
  function sum_digits_recursive (line 44) | pub fn sum_digits_recursive(num: i32) -> u32 {
  function zero (line 62) | fn zero() {
  function positive_number (line 66) | fn positive_number() {
  function negative_number (line 73) | fn negative_number() {
  function trailing_zeros (line 81) | fn trailing_zeros() {
  function zero (line 92) | fn zero() {
  function positive_number (line 96) | fn positive_number() {
  function negative_number (line 103) | fn negative_number() {
  function trailing_zeros (line 111) | fn trailing_zeros() {

FILE: src/math/sum_of_geometric_progression.rs
  function sum_of_geometric_progression (line 5) | pub fn sum_of_geometric_progression(first_term: f64, common_ratio: f64, ...

FILE: src/math/sum_of_harmonic_series.rs
  function sum_of_harmonic_progression (line 8) | pub fn sum_of_harmonic_progression(
  function test_sum_of_harmonic_progression (line 33) | fn test_sum_of_harmonic_progression() {

FILE: src/math/sylvester_sequence.rs
  function sylvester (line 6) | pub fn sylvester(number: i32) -> i128 {
  function test_sylvester (line 24) | fn test_sylvester() {
  function test_sylvester_negative (line 30) | fn test_sylvester_negative() {

FILE: src/math/tanh.rs
  function tanh (line 13) | pub fn tanh(array: &mut Vec<f32>) -> &mut Vec<f32> {
  function test_tanh (line 27) | fn test_tanh() {

FILE: src/math/trapezoidal_integration.rs
  function trapezoidal_integral (line 1) | pub fn trapezoidal_integral<F>(a: f64, b: f64, f: F, precision: u32) -> f64

FILE: src/math/trial_division.rs
  function floor (line 1) | fn floor(value: f64, scale: u8) -> f64 {
  function double_to_int (line 6) | fn double_to_int(amount: f64) -> i128 {
  function trial_division (line 10) | pub fn trial_division(mut num: i128) -> Vec<i128> {
  function basic (line 48) | fn basic() {

FILE: src/math/trig_functions.rs
  function template (line 7) | fn template<T: Into<f64>>(x: T, tol: f64, kind: i32) -> f64 {
  function sine (line 71) | pub fn sine<T: Into<f64>>(x: T, tol: f64) -> f64 {
  function cosine (line 77) | pub fn cosine<T: Into<f64>>(x: T, tol: f64) -> f64 {
  function cosine_no_radian_arg (line 82) | pub fn cosine_no_radian_arg<T: Into<f64>>(x: T, tol: f64) -> f64 {
  function sine_no_radian_arg (line 95) | pub fn sine_no_radian_arg<T: Into<f64>>(x: T, tol: f64) -> f64 {
  function tan (line 102) | pub fn tan<T: Into<f64> + Copy>(x: T, tol: f64) -> f64 {
  function cotan (line 115) | pub fn cotan<T: Into<f64> + Copy>(x: T, tol: f64) -> f64 {
  function tan_no_radian_arg (line 128) | pub fn tan_no_radian_arg<T: Into<f64> + Copy>(x: T, tol: f64) -> f64 {
  function cotan_no_radian_arg (line 136) | pub fn cotan_no_radian_arg<T: Into<f64> + Copy>(x: T, tol: f64) -> f64 {
  type TrigFuncType (line 148) | enum TrigFuncType {
    method verify (line 158) | fn verify<T: Into<f64> + Copy>(&self, angle: T, expected_result: f64, ...
  constant TOL (line 155) | const TOL: f64 = 1e-10;
  function test_sine (line 195) | fn test_sine() {
  function test_sine_bad_arg (line 209) | fn test_sine_bad_arg() {
  function test_cosine_bad_arg (line 215) | fn test_cosine_bad_arg() {
  function test_cosine (line 221) | fn test_cosine() {
  function test_tan_bad_arg (line 234) | fn test_tan_bad_arg() {
  function test_tan (line 240) | fn test_tan() {
  function test_cotan_bad_arg (line 251) | fn test_cotan_bad_arg() {
  function test_cotan (line 257) | fn test_cotan() {

FILE: src/math/vector_cross_product.rs
  function cross_product (line 13) | pub fn cross_product(vec1: [f64; 3], vec2: [f64; 3]) -> [f64; 3] {
  function vector_magnitude (line 21) | pub fn vector_magnitude(vec: [f64; 3]) -> f64 {
  function test_cross_product_and_magnitude_1 (line 30) | fn test_cross_product_and_magnitude_1() {
  function test_cross_product_and_magnitude_2 (line 44) | fn test_cross_product_and_magnitude_2() {
  function test_cross_product_and_magnitude_3 (line 58) | fn test_cross_product_and_magnitude_3() {
  function test_cross_product_and_magnitude_4 (line 72) | fn test_cross_product_and_magnitude_4() {
  function test_cross_product_and_magnitude_5 (line 86) | fn test_cross_product_and_magnitude_5() {

FILE: src/math/zellers_congruence_algorithm.rs
  function zellers_congruence_algorithm (line 3) | pub fn zellers_congruence_algorithm(date: i32, month: i32, year: i32, as...
  function number_to_day (line 29) | fn number_to_day(number: i32) -> String {
  function it_works (line 46) | fn it_works() {

FILE: src/navigation/bearing.rs
  function bearing (line 3) | pub fn bearing(lat1: f64, lng1: f64, lat2: f64, lng2: f64) -> f64 {
  function testing (line 26) | fn testing() {

FILE: src/navigation/haversine.rs
  constant EARTH_RADIUS (line 3) | const EARTH_RADIUS: f64 = 6371000.00;
  function haversine (line 5) | pub fn haversine(lat1: f64, lng1: f64, lat2: f64, lng2: f64) -> f64 {
  function testing (line 26) | fn testing() {

FILE: src/navigation/rhumbline.rs
  constant EARTH_RADIUS (line 3) | const EARTH_RADIUS: f64 = 6371000.0;
  function rhumb_dist (line 5) | pub fn rhumb_dist(lat1: f64, long1: f64, lat2: f64, long2: f64) -> f64 {
  function rhumb_bearing (line 27) | pub fn rhumb_bearing(lat1: f64, long1: f64, lat2: f64, long2: f64) -> f64 {
  function rhumb_destination (line 42) | pub fn rhumb_destination(lat: f64, long: f64, distance: f64, bearing: f6...
  function test_rhumb_distance (line 70) | fn test_rhumb_distance() {
  function test_rhumb_bearing (line 76) | fn test_rhumb_bearing() {
  function test_rhumb_destination_point (line 82) | fn test_rhumb_destination_point() {
  function test_rhumb_distance_cross_antimeridian (line 90) | fn test_rhumb_distance_cross_antimeridian() {
  function test_rhumb_distance_cross_antimeridian_negative (line 97) | fn test_rhumb_distance_cross_antimeridian_negative() {
  function test_rhumb_distance_to_equator (line 104) | fn test_rhumb_distance_to_equator() {

FILE: src/number_theory/compute_totient.rs
  function compute_totient (line 11) | pub fn compute_totient(n: i32) -> vec::Vec<i32> {
  function test_1 (line 44) | fn test_1() {
  function test_2 (line 52) | fn test_2() {
  function test_3 (line 57) | fn test_3() {

FILE: src/number_theory/euler_totient.rs
  function euler_totient (line 1) | pub fn euler_totient(n: u64) -> u64 {

FILE: src/number_theory/kth_factor.rs
  function kth_factor (line 4) | pub fn kth_factor(n: i32, k: i32) -> i32 {
  function test_1 (line 23) | fn test_1() {
  function test_2 (line 28) | fn test_2() {
  function test_3 (line 33) | fn test_3() {
  function test_4 (line 38) | fn test_4() {

FILE: src/searching/binary_search.rs
  function binary_search (line 25) | pub fn binary_search<T: Ord>(item: &T, arr: &[T]) -> Option<usize> {
  function match_compare (line 59) | fn match_compare<T: Ord>(
  function is_asc_arr (line 98) | fn is_asc_arr<T: Ord>(arr: &[T]) -> bool {

FILE: src/searching/binary_search_recursive.rs
  function binary_search_rec (line 23) | pub fn binary_search_rec<T: Ord>(item: &T, arr: &[T], left: usize, right...

FILE: src/searching/exponential_search.rs
  function exponential_search (line 3) | pub fn exponential_search<T: Ord>(item: &T, arr: &[T]) -> Option<usize> {
  function empty (line 35) | fn empty() {
  function one_item (line 41) | fn one_item() {
  function search_strings (line 47) | fn search_strings() {
  function search_ints (line 53) | fn search_ints() {
  function not_found (line 68) | fn not_found() {

FILE: src/searching/fibonacci_search.rs
  function fibonacci_search (line 4) | pub fn fibonacci_search<T: Ord>(item: &T, arr: &[T]) -> Option<usize> {
  function empty (line 47) | fn empty() {
  function one_item (line 53) | fn one_item() {
  function search_strings (line 59) | fn search_strings() {
  function search_ints (line 65) | fn search_ints() {
  function not_found (line 80) | fn not_found() {

FILE: src/searching/interpolation_search.rs
  function interpolation_search (line 1) | pub fn interpolation_search<Ordering>(nums: &[i32], item: &i32) -> Resul...
  function returns_err_if_empty_slice (line 29) | fn returns_err_if_empty_slice() {
  function returns_err_if_target_not_found (line 35) | fn returns_err_if_target_not_found() {
  function returns_first_index (line 41) | fn returns_first_index() {
  function returns_last_index (line 47) | fn returns_last_index() {
  function returns_middle_index (line 53) | fn returns_middle_index() {

FILE: src/searching/jump_search.rs
  function jump_search (line 3) | pub fn jump_search<T: Ord>(item: &T, arr: &[T]) -> Option<usize> {
  function empty (line 32) | fn empty() {
  function one_item (line 37) | fn one_item() {
  function search_strings (line 42) | fn search_strings() {
  function search_ints (line 50) | fn search_ints() {
  function not_found (line 59) | fn not_found() {

FILE: src/searching/kth_smallest.rs
  function kth_smallest (line 7) | pub fn kth_smallest<T>(input: &mut [T], k: usize) -> Option<T>
  function _kth_smallest (line 19) | fn _kth_smallest<T>(input: &mut [T], k: usize, lo: usize, hi: usize) -> T
  function empty (line 42) | fn empty() {
  function one_element (line 50) | fn one_element() {
  function many_elements (line 58) | fn many_elements() {

FILE: src/searching/kth_smallest_heap.rs
  function kth_smallest_heap (line 13) | pub fn kth_smallest_heap<T>(input: &[T], k: usize) -> Option<T>
  function empty (line 59) | fn empty() {
  function one_element (line 67) | fn one_element() {
  function many_elements (line 75) | fn many_elements() {

FILE: src/searching/linear_search.rs
  function linear_search (line 12) | pub fn linear_search<T: Ord>(item: &T, arr: &[T]) -> Option<usize> {

FILE: src/searching/moore_voting.rs
  function moore_voting (line 44) | pub fn moore_voting(arr: &[i32]) -> i32 {
  function test_moore_voting (line 74) | fn test_moore_voting() {

FILE: src/searching/quick_select.rs
  function partition (line 3) | fn partition(list: &mut [i32], left: usize, right: usize, pivot_index: u...
  function quick_select (line 17) | pub fn quick_select(list: &mut [i32], left: usize, right: usize, index: ...
  function it_works (line 36) | fn it_works() {

FILE: src/searching/saddleback_search.rs
  function saddleback_search (line 7) | pub fn saddleback_search(matrix: &[Vec<i32>], element: i32) -> (usize, u...
  function test_element_not_found (line 41) | fn test_element_not_found() {
  function test_element_at_top_left (line 48) | fn test_element_at_top_left() {
  function test_element_at_bottom_right (line 55) | fn test_element_at_bottom_right() {
  function test_element_at_top_right (line 62) | fn test_element_at_top_right() {
  function test_element_at_bottom_left (line 69) | fn test_element_at_bottom_left() {
  function test_element_in_middle (line 76) | fn test_element_in_middle() {

FILE: src/searching/ternary_search.rs
  function ternary_search (line 25) | pub fn ternary_search<T: Ord>(item: &T, arr: &[T]) -> Option<usize> {
  function match_compare (line 63) | fn match_compare<T: Ord>(
  function is_asc_arr (line 128) | fn is_asc_arr<T: Ord>(arr: &[T]) -> bool {

FILE: src/searching/ternary_search_min_max.rs
  function ternary_search_max (line 2) | pub fn ternary_search_max(
  function ternary_search_min (line 28) | pub fn ternary_search_min(
  function finds_max_value (line 58) | fn finds_max_value() {
  function finds_min_value (line 72) | fn finds_min_value() {
  function finds_max_value_2 (line 86) | fn finds_max_value_2() {
  function finds_min_value_2 (line 100) | fn finds_min_value_2() {

FILE: src/searching/ternary_search_min_max_recursive.rs
  function ternary_search_max_rec (line 2) | pub fn ternary_search_max_rec(
  function ternary_search_min_rec (line 26) | pub fn ternary_search_min_rec(
  function finds_max_value (line 54) | fn finds_max_value() {
  function finds_min_value (line 68) | fn finds_min_value() {
  function finds_max_value_2 (line 82) | fn finds_max_value_2() {
  function finds_min_value_2 (line 96) | fn finds_min_value_2() {

FILE: src/searching/ternary_search_recursive.rs
  function ternary_search_rec (line 3) | pub fn ternary_search_rec<T: Ord>(
  function returns_none_if_empty_list (line 36) | fn returns_none_if_empty_list() {
  function returns_none_if_range_is_invalid (line 42) | fn returns_none_if_range_is_invalid() {
  function returns_index_if_list_has_one_item (line 48) | fn returns_index_if_list_has_one_item() {
  function returns_first_index (line 54) | fn returns_first_index() {
  function returns_first_index_if_end_out_of_bounds (line 60) | fn returns_first_index_if_end_out_of_bounds() {
  function returns_last_index (line 66) | fn returns_last_index() {
  function returns_last_index_if_end_out_of_bounds (line 72) | fn returns_last_index_if_end_out_of_bounds() {
  function returns_middle_index (line 78) | fn returns_middle_index() {
  function returns_middle_index_if_end_out_of_bounds (line 84) | fn returns_middle_index_if_end_out_of_bounds() {

FILE: src/signal_analysis/yin.rs
  type YinResult (line 4) | pub struct YinResult {
    method get_frequency (line 11) | pub fn get_frequency(&self) -> f64 {
    method get_frequency_with_interpolation (line 15) | pub fn get_frequency_with_interpolation(&self) -> f64 {
  function parabolic_interpolation (line 21) | fn parabolic_interpolation(lag: usize, cmndf: &[f64]) -> f64 {
  type Yin (line 36) | pub struct Yin {
    method init (line 44) | pub fn init(
    method yin (line 60) | pub fn yin(&self, frequencies: &[f64]) -> Result<YinResult, String> {
  function difference_function_values (line 79) | fn difference_function_values(frequencies: &[f64], max_lag: usize) -> Ve...
  function difference_function (line 87) | fn difference_function(f: &[f64], lag: usize) -> f64 {
  constant EPSILON (line 97) | const EPSILON: f64 = 1e-10;
  function cumulative_mean_normalized_difference_function (line 98) | fn cumulative_mean_normalized_difference_function(df: &[f64], max_lag: u...
  function find_cmndf_argmin (line 109) | fn find_cmndf_argmin(cmndf: &[f64], min_lag: usize, max_lag: usize, thre...
  function generate_sine_wave (line 127) | fn generate_sine_wave(frequency: f64, sample_rate: f64, duration_secs: f...
  function diff_from_actual_frequency_smaller_than_threshold (line 139) | fn diff_from_actual_frequency_smaller_than_threshold(
  function interpolation_better_than_raw_result (line 148) | fn interpolation_better_than_raw_result(result: YinResult, frequency: f6...
  function test_simple_sine (line 157) | fn test_simple_sine() {
  function test_sine_frequency_range (line 192) | fn test_sine_frequency_range() {
  function test_harmonic_sines (line 232) | fn test_harmonic_sines() {
  function test_unharmonic_sines (line 269) | fn test_unharmonic_sines() {
  function test_err (line 311) | fn test_err() {

FILE: src/sorting/bead_sort.rs
  function bead_sort (line 3) | pub fn bead_sort(a: &mut [usize]) {
  function descending (line 43) | fn descending() {
  function mix_values (line 52) | fn mix_values() {

FILE: src/sorting/binary_insertion_sort.rs
  function _binary_search (line 1) | fn _binary_search<T: Ord>(arr: &[T], target: &T) -> usize {
  function binary_insertion_sort (line 18) | pub fn binary_insertion_sort<T: Ord + Clone>(arr: &mut [T]) {
  function test_binary_insertion_sort (line 35) | fn test_binary_insertion_sort() {

FILE: src/sorting/bingo_sort.rs
  function max_min (line 4) | fn max_min(vec: &[i32], bingo: &mut i32, next_bingo: &mut i32) {
  function bingo_sort (line 11) | pub fn bingo_sort(vec: &mut [i32]) {
  function print_array (line 37) | fn print_array(arr: &[i32]) {
  function test_bingo_sort (line 50) | fn test_bingo_sort() {
  function test_empty_array (line 65) | fn test_empty_array() {
  function test_single_element_array (line 72) | fn test_single_element_array() {
  function test_negative_numbers (line 79) | fn test_negative_numbers() {
  function test_already_sorted (line 86) | fn test_already_sorted() {
  function test_reverse_sorted (line 93) | fn test_reverse_sorted() {
  function test_duplicates (line 100) | fn test_duplicates() {

FILE: src/sorting/bitonic_sort.rs
  function _comp_and_swap (line 1) | fn _comp_and_swap<T: Ord>(array: &mut [T], left: usize, right: usize, as...
  function _bitonic_merge (line 7) | fn _bitonic_merge<T: Ord>(array: &mut [T], low: usize, length: usize, as...
  function bitonic_sort (line 18) | pub fn bitonic_sort<T: Ord>(array: &mut [T], low: usize, length: usize, ...
  function descending (line 36) | fn descending() {
  function ascending (line 45) | fn ascending() {

FILE: src/sorting/bogo_sort.rs
  constant DEFAULT (line 4) | const DEFAULT: u64 = 4294967296;
  function is_sorted (line 6) | fn is_sorted<T: Ord>(arr: &[T], len: usize) -> bool {
  function generate_index (line 17) | fn generate_index(range: usize, generator: &mut PCG32) -> usize {
  function generate_index (line 22) | fn generate_index(range: usize, generator: &mut PCG32) -> usize {
  function permute_randomly (line 29) | fn permute_randomly<T>(arr: &mut [T], len: usize, generator: &mut PCG32) {
  function bogo_sort (line 36) | pub fn bogo_sort<T: Ord>(arr: &mut [T]) {
  function random_array (line 55) | fn random_array() {
  function sorted_array (line 65) | fn sorted_array() {

FILE: src/sorting/bubble_sort.rs
  function bubble_sort (line 1) | pub fn bubble_sort<T: Ord>(arr: &mut [T]) {
  function descending (line 26) | fn descending() {
  function ascending (line 35) | fn ascending() {
  function empty (line 43) | fn empty() {

FILE: src/sorting/bucket_sort.rs
  function bucket_sort (line 7) | pub fn bucket_sort(arr: &[usize]) -> Vec<usize> {
  function empty (line 41) | fn empty() {
  function one_element (line 49) | fn one_element() {
  function already_sorted (line 57) | fn already_sorted() {
  function basic (line 65) | fn basic() {
  function odd_number_of_elements (line 73) | fn odd_number_of_elements() {
  function repeated_elements (line 81) | fn repeated_elements() {

FILE: src/sorting/cocktail_shaker_sort.rs
  function cocktail_shaker_sort (line 1) | pub fn cocktail_shaker_sort<T: Ord>(arr: &mut [T]) {
  function basic (line 44) | fn basic() {
  function empty (line 52) | fn empty() {
  function one_element (line 60) | fn one_element() {
  function pre_sorted (line 68) | fn pre_sorted() {

FILE: src/sorting/comb_sort.rs
  function comb_sort (line 1) | pub fn comb_sort<T: Ord>(arr: &mut [T]) {
  function descending (line 29) | fn descending() {
  function ascending (line 38) | fn ascending() {
  function duplicates (line 47) | fn duplicates() {

FILE: src/sorting/counting_sort.rs
  function counting_sort (line 6) | pub fn counting_sort(arr: &mut [u32], maxval: usize) {
  function generic_counting_sort (line 24) | pub fn generic_counting_sort<T: Into<u64> + From<u8> + AddAssign + Copy>(
  function counting_sort_descending (line 59) | fn counting_sort_descending() {
  function counting_sort_pre_sorted (line 68) | fn counting_sort_pre_sorted() {
  function generic_counting_sort (line 77) | fn generic_counting_sort() {
  function presorted_u64_counting_sort (line 86) | fn presorted_u64_counting_sort() {

FILE: src/sorting/cycle_sort.rs
  function cycle_sort (line 3) | pub fn cycle_sort(arr: &mut [i32]) {
  function it_works (line 42) | fn it_works() {

FILE: src/sorting/dutch_national_flag_sort.rs
  type Colors (line 9) | pub enum Colors {
  function dutch_national_flag_sort (line 17) | pub fn dutch_national_flag_sort(mut sequence: Vec<Colors>) -> Vec<Colors> {
  function random_array (line 51) | fn random_array() {
  function sorted_array (line 60) | fn sorted_array() {

FILE: src/sorting/exchange_sort.rs
  function exchange_sort (line 3) | pub fn exchange_sort(arr: &mut [i32]) {
  function it_works (line 20) | fn it_works() {

FILE: src/sorting/gnome_sort.rs
  function gnome_sort (line 3) | pub fn gnome_sort<T>(arr: &[T]) -> Vec<T>
  function basic (line 34) | fn basic() {
  function already_sorted (line 41) | fn already_sorted() {
  function odd_number_of_elements (line 48) | fn odd_number_of_elements() {
  function one_element (line 55) | fn one_element() {
  function empty (line 62) | fn empty() {

FILE: src/sorting/heap_sort.rs
  function build_heap (line 13) | fn build_heap<T: Ord>(arr: &mut [T], is_max_heap: bool) {
  function heapify (line 32) | fn heapify<T: Ord>(arr: &mut [T], i: usize, is_max_heap: bool) {
  function heap_sort (line 65) | pub fn heap_sort<T: Ord>(arr: &mut [T], ascending: bool) {

FILE: src/sorting/insertion_sort.rs
  function insertion_sort (line 5) | pub fn insertion_sort<T: Ord + Copy>(arr: &mut [T]) {
  function empty (line 26) | fn empty() {
  function one_element (line 34) | fn one_element() {
  function already_sorted (line 42) | fn already_sorted() {
  function basic (line 50) | fn basic() {
  function odd_number_of_elements (line 58) | fn odd_number_of_elements() {
  function repeated_elements (line 66) | fn repeated_elements() {

FILE: src/sorting/intro_sort.rs
  function insertion_sort (line 4) | fn insertion_sort<T: Ord>(arr: &mut [T]) {
  function heapify (line 14) | fn heapify<T: Ord>(arr: &mut [T], n: usize, i: usize) {
  function heap_sort (line 33) | fn heap_sort<T: Ord>(arr: &mut [T]) {
  function intro_sort (line 48) | pub fn intro_sort<T: Ord>(arr: &mut [T]) {
  function test_intro_sort (line 91) | fn test_intro_sort() {

FILE: src/sorting/merge_sort.rs
  function merge (line 1) | fn merge<T: Ord + Copy>(arr: &mut [T], mid: usize) {
  function top_down_merge_sort (line 22) | pub fn top_down_merge_sort<T: Ord + Copy>(arr: &mut [T]) {
  function bottom_up_merge_sort (line 34) | pub fn bottom_up_merge_sort<T: Copy + Ord>(a: &mut [T]) {
  function basic (line 67) | fn basic() {
  function basic_string (line 75) | fn basic_string() {
  function empty (line 83) | fn empty() {
  function one_element (line 91) | fn one_element() {
  function pre_sorted (line 99) | fn pre_sorted() {
  function reverse_sorted (line 107) | fn reverse_sorted() {
  function basic (line 122) | fn basic() {
  function basic_string (line 130) | fn basic_string() {
  function empty (line 138) | fn empty() {
  function one_element (line 146) | fn one_element() {
  function pre_sorted (line 154) | fn pre_sorted() {
  function reverse_sorted (line 162) | fn reverse_sorted() {

FILE: src/sorting/mod.rs
  function have_same_elements (line 77) | pub fn have_same_elements<T>(a: &[T], b: &[T]) -> bool
  function is_sorted (line 99) | pub fn is_sorted<T>(arr: &[T]) -> bool
  function is_descending_sorted (line 107) | pub fn is_descending_sorted<T>(arr: &[T]) -> bool
  function is_sorted (line 117) | fn is_sorted() {

FILE: src/sorting/odd_even_sort.rs
  function odd_even_sort (line 1) | pub fn odd_even_sort<T: Ord>(arr: &mut [T]) {
  function basic (line 34) | fn basic() {
  function empty (line 42) | fn empty() {
  function one_element (line 50) | fn one_element() {
  function pre_sorted (line 58) | fn pre_sorted() {

FILE: src/sorting/pancake_sort.rs
  function pancake_sort (line 3) | pub fn pancake_sort<T>(arr: &mut [T]) -> Vec<T>
  function basic (line 32) | fn basic() {
  function already_sorted (line 38) | fn already_sorted() {
  function odd_number_of_elements (line 44) | fn odd_number_of_elements() {
  function one_element (line 50) | fn one_element() {
  function empty (line 56) | fn empty() {

FILE: src/sorting/patience_sort.rs
  function patience_sort (line 3) | pub fn patience_sort<T: Ord + Copy>(arr: &mut [T]) {
  function basic (line 54) | fn basic() {
  function empty (line 64) | fn empty() {
  function one_element (line 72) | fn one_element() {
  function pre_sorted (line 80) | fn pre_sorted() {

FILE: src/sorting/pigeonhole_sort.rs
  function pigeonhole_sort (line 3) | pub fn pigeonhole_sort(array: &mut [i32]) {
  function test1 (line 30) | fn test1() {

FILE: src/sorting/quick_sort.rs
  function partition (line 1) | pub fn partition<T: PartialOrd>(arr: &mut [T], lo: usize, hi: usize) -> ...
  function _quick_sort (line 26) | fn _quick_sort<T: Ord>(arr: &mut [T], mut lo: usize, mut hi: usize) {
  function quick_sort (line 42) | pub fn quick_sort<T: Ord>(arr: &mut [T]) {
  function basic (line 57) | fn basic() {
  function basic_string (line 65) | fn basic_string() {
  function empty (line 73) | fn empty() {
  function one_element (line 81) | fn one_element() {
  function pre_sorted (line 89) | fn pre_sorted() {
  function reverse_sorted (line 97) | fn reverse_sorted() {
  function large_elements (line 105) | fn large_elements() {
  function nearly_ordered_elements (line 115) | fn nearly_ordered_elements() {
  function repeated_elements (line 127) | fn repeated_elements() {

FILE: src/sorting/quick_sort_3_ways.rs
  function _quick_sort_3_ways (line 5) | fn _quick_sort_3_ways<T: Ord>(arr: &mut [T], lo: usize, hi: usize) {
  function quick_sort_3_ways (line 43) | pub fn quick_sort_3_ways<T: Ord>(arr: &mut [T]) {
  function basic (line 58) | fn basic() {
  function basic_string (line 69) | fn basic_string() {
  function empty (line 80) | fn empty() {
  function one_element (line 91) | fn one_element() {
  function pre_sorted (line 102) | fn pre_sorted() {
  function reverse_sorted (line 113) | fn reverse_sorted() {
  function large_elements (line 124) | fn large_elements() {
  function nearly_ordered_elements (line 134) | fn nearly_ordered_elements() {
  function repeated_elements (line 146) | fn repeated_elements() {

FILE: src/sorting/radix_sort.rs
  function radix_sort (line 8) | pub fn radix_sort(arr: &mut [u64]) {
  function empty (line 44) | fn empty() {
  function descending (line 52) | fn descending() {
  function ascending (line 60) | fn ascending() {

FILE: src/sorting/selection_sort.rs
  function selection_sort (line 1) | pub fn selection_sort<T: Ord>(arr: &mut [T]) {
  function basic (line 21) | fn basic() {
  function empty (line 29) | fn empty() {
  function one_element (line 37) | fn one_element() {
  function pre_sorted (line 45) | fn pre_sorted() {

FILE: src/sorting/shell_sort.rs
  function shell_sort (line 1) | pub fn shell_sort<T: Ord + Copy>(values: &mut [T]) {
  function basic (line 32) | fn basic() {
  function empty (line 40) | fn empty() {
  function reverse (line 48) | fn reverse() {
  function already_sorted (line 56) | fn already_sorted() {

FILE: src/sorting/sleep_sort.rs
  function sleep_sort (line 5) | pub fn sleep_sort(vec: &[usize]) -> Vec<usize> {
  function empty (line 30) | fn empty() {
  function single_element (line 36) | fn single_element() {
  function sorted_array (line 42) | fn sorted_array() {
  function unsorted_array (line 48) | fn unsorted_array() {
  function odd_number_of_elements (line 54) | fn odd_number_of_elements() {
  function repeated_elements (line 60) | fn repeated_elements() {
  function random_elements (line 66) | fn random_elements() {

FILE: src/sorting/sort_utils.rs
  function generate_random_vec (line 5) | pub fn generate_random_vec(n: u32, range_l: i32, range_r: i32) -> Vec<i3...
  function generate_nearly_ordered_vec (line 19) | pub fn generate_nearly_ordered_vec(n: u32, swap_times: u32) -> Vec<i32> {
  function generate_ordered_vec (line 37) | pub fn generate_ordered_vec(n: u32) -> Vec<i32> {
  function generate_reverse_ordered_vec (line 42) | pub fn generate_reverse_ordered_vec(n: u32) -> Vec<i32> {
  function generate_repeated_elements_vec (line 49) | pub fn generate_repeated_elements_vec(n: u32, unique_elements: u8) -> Ve...
  function log_timed (line 56) | pub fn log_timed<F>(test_name: &str, f: F)

FILE: src/sorting/stooge_sort.rs
  function _stooge_sort (line 1) | fn _stooge_sort<T: Ord>(arr: &mut [T], start: usize, end: usize) {
  function stooge_sort (line 17) | pub fn stooge_sort<T: Ord>(arr: &mut [T]) {
  function basic (line 33) | fn basic() {
  function empty (line 41) | fn empty() {
  function reverse (line 49) | fn reverse() {
  function already_sorted (line 57) | fn already_sorted() {

FILE: src/sorting/tim_sort.rs
  function compute_min_run_length (line 22) | fn compute_min_run_length(array_length: usize) -> usize {
  function merge (line 44) | fn merge<T: Ord + Copy>(arr: &mut [T], left: usize, mid: usize, right: u...
  function tim_sort (line 84) | pub fn tim_sort<T: Ord + Copy>(arr: &mut [T]) {
  function min_run_length_returns_correct_value (line 118) | fn min_run_length_returns_correct_value() {

FILE: src/sorting/tree_sort.rs
  type TreeNode (line 7) | struct TreeNode<T> {
  function new (line 14) | fn new(value: T) -> Self {
  type BinarySearchTree (line 23) | struct BinarySearchTree<T> {
  function new (line 28) | fn new() -> Self {
  function insert (line 32) | fn insert(&mut self, value: T) {
  function insert_recursive (line 36) | fn insert_recursive(root: Option<Box<TreeNode<T>>>, value: T) -> Box<Tre...
  function in_order_traversal (line 50) | fn in_order_traversal(&self, result: &mut Vec<T>) {
  function in_order_recursive (line 54) | fn in_order_recursive(root: &Option<Box<TreeNode<T>>>, result: &mut Vec<...
  function tree_sort (line 63) | pub fn tree_sort<T: Ord + Clone>(arr: &mut Vec<T>) {
  function test_empty_array (line 81) | fn test_empty_array() {
  function test_single_element (line 88) | fn test_single_element() {
  function test_already_sorted (line 95) | fn test_already_sorted() {
  function test_reverse_sorted (line 102) | fn test_reverse_sorted() {
  function test_random (line 109) | fn test_random() {

FILE: src/sorting/wave_sort.rs
  function wave_sort (line 18) | pub fn wave_sort<T: Ord>(arr: &mut [T]) {
  function test_case_1 (line 32) | fn test_case_1() {
  function test_case_2 (line 40) | fn test_case_2() {
  function test_case_3 (line 48) | fn test_case_3() {
  function test_case_4 (line 56) | fn test_case_4() {
  function test_case_5 (line 64) | fn test_case_5() {

FILE: src/sorting/wiggle_sort.rs
  function wiggle_sort (line 8) | pub fn wiggle_sort(nums: &mut Vec<i32>) -> &mut Vec<i32> {
  function is_wiggle_sorted (line 35) | fn is_wiggle_sorted(nums: &[i32]) -> bool {
  function wingle_elements (line 53) | fn wingle_elements() {
  function odd_number_of_elements (line 62) | fn odd_number_of_elements() {
  function repeated_elements (line 71) | fn repeated_elements() {

FILE: src/string/aho_corasick.rs
  type ACNode (line 7) | struct ACNode {
  type AhoCorasick (line 14) | pub struct AhoCorasick {
    method new (line 19) | pub fn new(words: &[&str]) -> Self {
    method build_suffix (line 32) | fn build_suffix(root: Rc<RefCell<ACNode>>) {
    method search (line 63) | pub fn search<'a>(&self, s: &'a str) -> Vec<&'a str> {
  function test_aho_corasick (line 93) | fn test_aho_corasick() {
  function test_aho_corasick_with_utf8 (line 101) | fn test_aho_corasick_with_utf8() {

FILE: src/string/anagram.rs
  type AnagramError (line 5) | pub enum AnagramError {
  function check_anagram (line 21) | pub fn check_anagram(s: &str, t: &str) -> Result<bool, AnagramError> {
  function clean_string (line 39) | fn clean_string(s: &str) -> Result<String, AnagramError> {
  function char_count (line 61) | fn char_count(s: &str) -> HashMap<char, usize> {

FILE: src/string/autocomplete_using_trie.rs
  constant END (line 11) | const END: char = '#';
  type Trie (line 14) | struct Trie(HashMap<char, Box<Trie>>);
    method new (line 17) | fn new() -> Self {
    method insert (line 21) | fn insert(&mut self, text: &str) {
    method find (line 31) | fn find(&self, prefix: &str) -> Vec<String> {
    method _elements (line 49) | fn _elements(map: &Trie) -> Vec<String> {
  type Autocomplete (line 70) | pub struct Autocomplete {
    method new (line 75) | fn new() -> Self {
    method insert_words (line 79) | pub fn insert_words<T: AsRef<str>>(&mut self, words: &[T]) {
    method find_words (line 85) | pub fn find_words(&self, prefix: &str) -> Vec<String> {
  method default (line 91) | fn default() -> Self {
  function test_autocomplete (line 101) | fn test_autocomplete() {

FILE: src/string/boyer_moore_search.rs
  function build_bad_char_table (line 17) | fn build_bad_char_table(pat: &[char]) -> HashMap<char, isize> {
  function calc_match_shift (line 37) | fn calc_match_shift(
  function calc_mismatch_shift (line 62) | fn calc_mismatch_shift(
  function boyer_moore_search (line 85) | pub fn boyer_moore_search(text: &str, pat: &str) -> Vec<usize> {

FILE: src/string/burrows_wheeler_transform.rs
  function burrows_wheeler_transform (line 1) | pub fn burrows_wheeler_transform(input: &str) -> (String, usize) {
  function inv_burrows_wheeler_transform (line 22) | pub fn inv_burrows_wheeler_transform<T: AsRef<str>>(input: (T, usize)) -...
  function stand_alone_function (line 47) | fn stand_alone_function() {
  function basic_characters (line 71) | fn basic_characters() {
  function special_characters (line 95) | fn special_characters() {
  function empty (line 111) | fn empty() {

FILE: src/string/duval_algorithm.rs
  function duval_algorithm (line 20) | pub fn duval_algorithm(s: &str) -> Vec<String> {
  function factorize_duval (line 34) | fn factorize_duval(s: &[char]) -> Vec<String> {

FILE: src/string/hamming_distance.rs
  type HammingDistanceError (line 3) | pub enum HammingDistanceError {
  function hamming_distance (line 10) | pub fn hamming_distance(string_a: &str, string_b: &str) -> Result<usize,...

FILE: src/string/isogram.rs
  type IsogramError (line 8) | pub enum IsogramError {
  function count_letters (line 31) | fn count_letters(s: &str) -> Result<HashMap<char, usize>, IsogramError> {
  function is_isogram (line 60) | pub fn is_isogram(s: &str) -> Result<bool, IsogramError> {

FILE: src/string/isomorphism.rs
  function is_isomorphic (line 17) | pub fn is_isomorphic(s: &str, t: &str) -> bool {
  function check_mapping (line 46) | fn check_mapping(map: &mut HashMap<char, char>, key: char, value: char) ...

FILE: src/string/jaro_winkler_distance.rs
  function jaro_winkler_distance (line 7) | pub fn jaro_winkler_distance(str1: &str, str2: &str) -> f64 {
  function test_jaro_winkler_distance (line 70) | fn test_jaro_winkler_distance() {

FILE: src/string/knuth_morris_pratt.rs
  function knuth_morris_pratt (line 18) | pub fn knuth_morris_pratt(string: &str, pattern: &str) -> Vec<usize> {
  function build_partial_match_table (line 42) | fn build_partial_match_table(pattern_chars: &[char]) -> Vec<usize> {
  function find_pattern (line 76) | fn find_pattern(

FILE: src/string/levenshtein_distance.rs
  function naive_levenshtein_distance (line 34) | pub fn naive_levenshtein_distance(string1: &str, string2: &str) -> usize {
  function optimized_levenshtein_distance (line 89) | pub fn optimized_levenshtein_distance(string1: &str, string2: &str) -> u...
  function _min3 (line 123) | fn _min3<T: Ord>(a: T, b: T, c: T) -> T {
  constant LEVENSHTEIN_DISTANCE_TEST_CASES (line 129) | const LEVENSHTEIN_DISTANCE_TEST_CASES: &[(&str, &str, usize)] = &[

FILE: src/string/lipogram.rs
  type LipogramError (line 5) | pub enum LipogramError {
  function compute_missing (line 21) | fn compute_missing(in_str: &str) -> HashSet<char> {
  function is_lipogram (line 44) | pub fn is_lipogram(

FILE: src/string/manacher.rs
  function manacher (line 1) | pub fn manacher(s: String) -> String {
  function get_longest_palindrome_by_manacher (line 83) | fn get_longest_palindrome_by_manacher() {

FILE: src/string/palindrome.rs
  function is_palindrome (line 15) | pub fn is_palindrome(s: &str) -> bool {

FILE: src/string/pangram.rs
  type PangramStatus (line 11) | pub enum PangramStatus {
  function compute_letter_counts (line 17) | fn compute_letter_counts(pangram_str: &str) -> std::collections::HashMap...
  function is_pangram (line 40) | pub fn is_pangram(pangram_str: &str) -> PangramStatus {

FILE: src/string/rabin_karp.rs
  constant MOD (line 5) | const MOD: usize = 101;
  constant RADIX (line 6) | const RADIX: usize = 256;
  function rabin_karp (line 16) | pub fn rabin_karp(text: &str, pattern: &str) -> Vec<usize> {
  function compute_hash (line 51) | fn compute_hash(s: &str) -> usize {
  function update_hash (line 70) | fn update_hash(

FILE: src/string/reverse.rs
  function reverse (line 10) | pub fn reverse(text: &str) -> String {

FILE: src/string/run_length_encoding.rs
  function run_length_encoding (line 1) | pub fn run_length_encoding(target: &str) -> String {
  function run_length_decoding (line 28) | pub fn run_length_decoding(target: &str) -> String {

FILE: src/string/shortest_palindrome.rs
  function shortest_palindrome (line 19) | pub fn shortest_palindrome(s: &str) -> String {
  function compute_suffix (line 47) | pub fn compute_suffix(chars: &[char]) -> Vec<usize> {
  function compute_prefix_match (line 73) | pub fn compute_prefix_match(original: &[char], reversed: &[char], suffix...

FILE: src/string/suffix_array.rs
  type Suffix (line 8) | struct Suffix {
    method cmp (line 14) | fn cmp(&self, b: &Self) -> Ordering {
  function generate_suffix_array (line 30) | pub fn generate_suffix_array(txt: &str) -> Vec<usize> {
  function test_suffix_array (line 91) | fn test_suffix_array() {

FILE: src/string/suffix_array_manber_myers.rs
  function generate_suffix_array_manber_myers (line 1) | pub fn generate_suffix_array_manber_myers(input: &str) -> Vec<usize> {
  function test_suffix_array (line 61) | fn test_suffix_array() {
  function test_empty_string (line 68) | fn test_empty_string() {
  function test_single_character (line 75) | fn test_single_character() {
  function test_repeating_characters (line 81) | fn test_repeating_characters() {
  function test_long_string (line 88) | fn test_long_string() {
  function test_mix_of_characters (line 95) | fn test_mix_of_characters() {
  function test_whitespace_characters (line 102) | fn test_whitespace_characters() {

FILE: src/string/suffix_tree.rs
  type Node (line 7) | pub struct Node {
    method new (line 13) | fn new(sub: String, children: Vec<usize>) -> Self {
    method empty (line 19) | pub fn empty() -> Self {
  type SuffixTree (line 27) | pub struct SuffixTree {
    method new (line 32) | pub fn new(s: &str) -> Self {
    method add_suffix (line 42) | fn add_suffix(&mut self, suf: &str) {
  function test_suffix_tree (line 100) | fn test_suffix_tree() {

FILE: src/string/z_algorithm.rs
  function calculate_z_value (line 15) | fn calculate_z_value<T: Eq>(
  function initialize_z_array_from_previous_match (line 44) | fn initialize_z_array_from_previous_match(
  function find_full_matches (line 62) | fn find_full_matches(z_array: &[usize], pattern_size: usize) -> Vec<usiz...
  function match_with_z_array (line 81) | fn match_with_z_array<T: Eq>(
  function z_array (line 123) | pub fn z_array<T: Eq>(input: &[T]) -> Vec<usize> {
  function match_pattern (line 138) | pub fn match_pattern<T: Eq>(input: &[T], pattern: &[T]) -> Vec<usize> {