Functions — github.com/Daniel-Liu-c0deb0t/triple

hub / github.com/Daniel-Liu-c0deb0t/triple_accel / functions

Functions97 in github.com/Daniel-Liu-c0deb0t/triple_accel

↓ 28 callersFunctionlevenshtein_simd_k_with_opts

Returns the Levenshtein distance, bounded by a cost threshold `k`, between two strings and optionally, the edit traceback, using SIMD acceleration, wi

src/levenshtein.rs:714

↓ 23 callersFunctionlevenshtein_search_simd_with_opts

Returns an iterator over `Match`s by searching through the text `haystack` for the pattern `needle` using SIMD acceleration, with extra options. Note

src/levenshtein.rs:1911

↓ 21 callersFunctionlevenshtein_naive_k_with_opts

( a: &[T], b: &[T], k: u32, trace_on: bool, costs: EditCosts, )

src/levenshtein.rs:376

↓ 20 callersFunctionlevenshtein_search_naive_with_opts

Returns an iterator over `Match`s by searching through the text `haystack` for the pattern `needle` using the naive algorithm, with extra options. No

src/levenshtein.rs:1589

↓ 14 callersFunctionlevenshtein_naive_with_opts

( a: &[T], b: &[T], trace_on: bool, costs: EditCosts, )

src/levenshtein.rs:148

↓ 8 callersFunctionlevenshtein_naive

Returns the Levenshtein distance between two strings using the naive scalar algorithm. # Arguments `a` - first string (slice) `b` - second string (sl

src/levenshtein.rs:105

↓ 8 callersMethodupper_bound

(&self)

src/jewel.rs:499

↓ 7 callersFunctionalloc_str

(len: usize)

src/lib.rs:197

↓ 6 callersFunctionfill_str

(dest: &mut [u8], src: &[u8])

src/lib.rs:229

↓ 6 callersFunctionhamming_naive

Returns the hamming distance between two strings by naively counting mismatches. The length of `a` and `b` must be the same. # Arguments `a` - first

src/hamming.rs:36

↓ 6 callersFunctionlevenshtein

Returns the Levenshtein distance between two strings using SIMD acceleration. Note that `levenshtein_exp` may be much faster if the number of edits b

src/levenshtein.rs:1397

↓ 6 callersFunctionlevenshtein_exp

Returns the Levenshtein distance between two strings using exponential search and SIMD acceleration. This may be much more efficient than `levenshtei

src/levenshtein.rs:1445

↓ 5 callersFunctionhamming_search_naive_with_opts

Returns an iterator over `Match`s by naively searching through the text `haystack` for the pattern `needle`, with extra options. Only matches with le

src/hamming.rs:96

↓ 5 callersFunctionrdamerau

Returns the restricted Damerau-Levenshtein distance between two strings using SIMD acceleration. Note that `rdamerau_exp` may be much faster if the n

src/levenshtein.rs:1419

↓ 5 callersFunctionrdamerau_exp

Returns the restricted Damerau-Levenshtein distance between two strings using exponential search and SIMD acceleration. This may be much more efficie

src/levenshtein.rs:1516

↓ 4 callersFunctionhamming_simd_parallel

Returns the hamming distance between two strings by counting mismatches using SIMD vectors to increment multiple counters in parallel. The length of

src/hamming.rs:317

↓ 4 callersFunctionlevenshtein_simd_k

Returns the Levenshtein distance, bounded by a cost threshold `k`, between two strings, using SIMD acceleration. This will return `None` if the Leven

src/levenshtein.rs:677

↓ 3 callersFunctionhamming_search_simd_with_opts

Returns an iterator over `Match`s by searching through the text `haystack` for the pattern `needle` using SIMD, with extra options. This is done by u

src/hamming.rs:454

↓ 3 callersFunctionhamming_simd_movemask

Returns the hamming distance between two strings by counting mismatches using the SIMD movemask intrinsic. The length of `a` and `b` must be the same

src/hamming.rs:354

↓ 2 callersMethodcheck_search

For Levenshtein searches, the cost of transpositions must be less than or equal to cost of gaps. This is important for free gaps at the beginning of

src/levenshtein.rs:67

↓ 2 callersFunctionhamming_search_simd

Returns an iterator over best `Match`s by searching through the text `haystack` for the pattern `needle` using SIMD. This is done by counting mismatc

src/hamming.rs:422

↓ 2 callersFunctionhamming_words_128

Returns the hamming distance between two strings by counting mismatches in chunks of 128 bits. The length of `a` and `b` must be the same. Both `a` a

src/hamming.rs:249

↓ 2 callersFunctionhamming_words_64

Returns the hamming distance between two strings by efficiently counting mismatches in chunks of 64 bits. The length of `a` and `b` must be the same.

src/hamming.rs:176

↓ 2 callersFunctionlevenshtein_search_simd

Returns an iterator over the best `Match`s by searching through the text `haystack` for the pattern `needle` using SIMD acceleration. The best matche

src/levenshtein.rs:1866

↓ 2 callersFunctionrand_alloc_str

(length: usize, rng: &mut R)

benches/rand_benchmarks.rs:251

↓ 2 callersFunctionrand_hamming_mutate

(a: &[u8], k: u32, rng: &mut R)

benches/rand_benchmarks.rs:161

↓ 2 callersFunctionrand_levenshtein_mutate

(a: &[u8], k: u32, rng: &mut R)

benches/rand_benchmarks.rs:207

↓ 2 callersFunctionrand_levenshtein_pair

(length: usize, k: u32, rng: &mut R)

benches/rand_benchmarks.rs:200

↓ 2 callersFunctionrand_str

(length: usize, rng: &mut R)

benches/rand_benchmarks.rs:240

↓ 2 callersFunctiontranslate_str

(chars: &mut Vec<char>, s: &str)

src/levenshtein.rs:609

↓ 1 callersFunctioncheck_no_null_bytes

(s: &[u8])

src/lib.rs:237

↓ 1 callersFunctionhamming_search_naive

Returns an iterator over best `Match`s by naively searching through the text `haystack` for the pattern `needle`. This is done by naively counting mi

src/hamming.rs:70

↓ 1 callersFunctionlevenshtein_search_naive

Returns an iterator over the best `Match`s by searching through the text `haystack` for the pattern `needle` using the naive algorithm. The best matc

src/levenshtein.rs:1549

↓ 1 callersFunctionrand_hamming_needle_haystack

(needle_len: usize, haystack_len: usize, num_match: usize, k: u32, rng: &mut R)

benches/rand_benchmarks.rs:126

↓ 1 callersFunctionrand_hamming_pair

(length: usize, k: u32, rng: &mut R)

benches/rand_benchmarks.rs:154

↓ 1 callersFunctionrand_levenshtein_needle_haystack

(needle_len: usize, haystack_len: usize, num_match: usize, k: u32, rng: &mut R)

benches/rand_benchmarks.rs:175

Function_mm256_adds_epu32

(a: __m256i, b: __m256i)

src/jewel.rs:843

Function_mm_adds_epu32

(a: __m128i, b: __m128i)

src/jewel.rs:1906

Functionbench_rand_hamming

(c: &mut Criterion)

benches/rand_benchmarks.rs:7

Functionbench_rand_hamming_search

(c: &mut Criterion)

benches/rand_benchmarks.rs:33

Functionbench_rand_levenshtein

(c: &mut Criterion)

benches/rand_benchmarks.rs:55

Functionbench_rand_levenshtein_k

(c: &mut Criterion)

benches/rand_benchmarks.rs:77

Functionbench_rand_levenshtein_search

(c: &mut Criterion)

benches/rand_benchmarks.rs:100

Methodblendv_mut

(&mut self, b: &Self, mask: &Self)

src/jewel.rs:608

Methodcount_mismatches

(a_ptr: *const u8, b_ptr: *const u8, len: usize)

src/jewel.rs:2320

Methoddouble_min_length

(new_gap: &Self, res_cont_gap: &mut Self, new_gap_length: &Self, res_cont_gap_length: &mut Self)

src/jewel.rs:769

Methodfmt

(&self, f: &mut fmt::Formatter)

src/jewel.rs:794

Methodfmt_internal

(s: &AvxNx16x16, f: &mut fmt::Formatter)

src/jewel.rs:798

Functionhamming

Returns the hamming distance between two strings using the best method. The length of `a` and `b` must be the same. This will automatically fall back

src/hamming.rs:390

Functionhamming_search

Returns an iterator over best `Match`s by searching through the text `haystack` for the pattern `needle` using SIMD. This will automatically fall bac

src/hamming.rs:588

Methodinsert_first

(&mut self, val: u32)

src/jewel.rs:588

Methodinsert_first_max

(&mut self)

src/jewel.rs:594

Methodinsert_last_0

(&mut self, val: u32)

src/jewel.rs:560

Methodinsert_last_1

(&mut self, val: u32)

src/jewel.rs:567

Methodinsert_last_2

(&mut self, val: u32)

src/jewel.rs:574

Methodinsert_last_max

(&mut self)

src/jewel.rs:581

Functionlevenshtein_exp_with_opts

Returns the Levenshtein distance between two strings, and optionally, the edit traceback, using exponential search and SIMD acceleration. Extra option

src/levenshtein.rs:1480

Functionlevenshtein_naive_k

Returns the Levenshtein distance, bounded by a cost threshold `k`, between two strings, using the naive scalar algorithm. This will return `None` if

src/levenshtein.rs:342

Functionlevenshtein_search

Returns an iterator over best `Match`s by searching through the text `haystack` for the pattern `needle` using SIMD acceleration. The best matches ar

src/levenshtein.rs:2508

Functionlevenshtein_simd_k_str

Returns the Levenshtein distance, bounded by a cost threshold `k`, between two utf8 encoded strings, using SIMD acceleration. # Arguments `a` - first

src/levenshtein.rs:641

Functionlevenstein_naive_str

Returns the Levenshtein distance between two strings using the naive scalar algorithm. # Arguments `a` - first string (&str) `b` - second string (&st

src/levenshtein.rs:123

Methodloadu

(ptr: *const u8, len: usize)

src/jewel.rs:2264

Methodmm_count_mismatches

(a_ptr: *const u8, b_ptr: *const u8, len: usize)

src/jewel.rs:2297

Methodnew

Create a new `EditCosts` struct, checking for whether the specified costs are valid. # Arguments `mismatch_cost` - cost of a mismatch edit, which mus

src/levenshtein.rs:38

Methodrepeating

(val: u32, len: usize)

(a: &Self, res: &mut Self)

src/jewel.rs:673

Methodshift_left_1_mut

(&mut self)

src/jewel.rs:616

Methodshift_left_2_mut

(&mut self)

src/jewel.rs:633

Methodshift_right_1

(a: &Self, res: &mut Self)

src/jewel.rs:690

Methodshift_right_1_mut

(&mut self, i: usize, val: u32)

src/jewel.rs:548

Methodslow_loadu

(&mut self, idx: usize, ptr: *const u8, len: usize, reverse: bool)

src/jewel.rs:510

Methodstatic_upper_bound

()

src/jewel.rs:504

Functiontest_basic_hamming_naive

()

tests/basic_tests.rs:6

Functiontest_basic_hamming_search_naive

()

tests/basic_tests.rs:19

Functiontest_basic_hamming_search_simd

()

tests/basic_tests.rs:32

Functiontest_basic_hamming_simd_movemask

()

tests/basic_tests.rs:75

Functiontest_basic_hamming_simd_parallel

()

tests/basic_tests.rs:88

Functiontest_basic_hamming_words_128

()

tests/basic_tests.rs:60

Functiontest_basic_hamming_words_64

()

tests/basic_tests.rs:45

Functiontest_basic_levenshtein

()

tests/basic_tests.rs:198

Functiontest_basic_levenshtein_exp

()

tests/basic_tests.rs:226

Functiontest_basic_levenshtein_naive

()

tests/basic_tests.rs:101

Functiontest_basic_levenshtein_naive_k_with_opts

()

tests/basic_tests.rs:310

Functiontest_basic_levenshtein_search_naive

()

tests/basic_tests.rs:580

Functiontest_basic_levenshtein_search_simd

()

tests/basic_tests.rs:684

Functiontest_basic_levenshtein_simd_k_with_opts

()

tests/basic_tests.rs:430

Functiontest_basic_rdamerau

()

tests/basic_tests.rs:254

Functiontest_basic_rdamerau_exp

()

tests/basic_tests.rs:282

Functiontest_trace_on_levenshtein_naive

()

tests/basic_tests.rs:164

Functiontest_trace_on_levenshtein_naive_k_with_opts

()

tests/basic_tests.rs:396

Functiontest_trace_on_levenshtein_simd_k_with_opts

()

tests/basic_tests.rs:546

Methodtriple_argmin

(sub: &Self, a_gap: &Self, b_gap: &Self, res_min: &mut Self)

src/jewel.rs:706

Methodtriple_min_length

(sub: &Self, a_gap: &Self, b_gap: &Self, sub_length: &Self, a_gap_length: &Sel

src/jewel.rs:735

Methodvector_count_mismatches

(a: &Self, b_ptr: *const u8, len: usize)

src/jewel.rs:2369