Class EditDistance
Provides functions for calculating edit-distance.
Namespace: Stringier
Assembly: Stringier.Metrics.dll
Syntax
public static class EditDistance : object
Methods
| Improve this Doc View SourceHamming(Char*, Int32, Char*, Int32)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 firstLength, Char*second, Int32 secondLength)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | firstLength | The length of the |
| Char* | second | The second text. |
| Int32 | secondLength | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, Char*, Int32, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 firstLength, Char*second, Int32 secondLength, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | firstLength | The length of the |
| Char* | second | The second text. |
| Int32 | secondLength | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, Char[])
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, Char[], Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Char[] | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, Memory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, Memory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Memory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, ReadOnlyMemory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, ReadOnlyMemory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| ReadOnlyMemory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, ReadOnlySpan<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, ReadOnlySpan<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| ReadOnlySpan<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, Span<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, Span<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Span<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, String)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char*, Int32, String, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char*first, Int32 length, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| String | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], Char*, Int32)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], Char*, Int32, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], Char[])
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], Char[], Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Char[] | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], Memory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], Memory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Memory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], ReadOnlyMemory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], ReadOnlyMemory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], ReadOnlySpan<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], ReadOnlySpan<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], Span<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], Span<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Span<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], String)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Char[], String, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Char[] first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| String | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, Char*, Int32)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, Char*, Int32, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, Char[])
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, Char[], Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Char[] | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, Memory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, Memory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, ReadOnlyMemory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, ReadOnlyMemory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, ReadOnlySpan<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, ReadOnlySpan<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, Span<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, Span<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Span<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, String)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Memory<Char>, String, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Memory<Char> first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| String | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, Char*, Int32)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, Char*, Int32, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, Char[])
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, Char[], Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Char[] | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, Memory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, Memory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, ReadOnlyMemory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, ReadOnlyMemory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, ReadOnlySpan<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, ReadOnlySpan<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, Span<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, Span<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Span<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, String)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlyMemory<Char>, String, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlyMemory<Char> first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| String | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, Char*, Int32)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, Char*, Int32, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, Char[])
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, Char[], Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Char[] | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, Memory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, Memory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, ReadOnlyMemory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, ReadOnlyMemory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, ReadOnlySpan<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, Span<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, Span<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Span<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, String)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(ReadOnlySpan<Char>, String, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(ReadOnlySpan<Char> first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| String | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, Char*, Int32)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, Char*, Int32, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, Char[])
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, Char[], Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Char[] | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, Memory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, Memory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, ReadOnlyMemory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, ReadOnlyMemory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, ReadOnlySpan<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, ReadOnlySpan<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, Span<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, Span<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Span<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, String)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(Span<Char>, String, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(Span<Char> first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| String | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, Char*, Int32)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, Char*, Int32, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, Char[])
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, Char[], Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Char[] | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, Memory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, Memory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Memory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, ReadOnlyMemory<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, ReadOnlyMemory<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, ReadOnlySpan<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, ReadOnlySpan<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, Span<Char>)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, Span<Char>, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Span<Char> | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, String)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Hamming(String, String, Case)
Calculates the Hamming edit-distance between the first
and second
.
Declaration
public static Int32 Hamming(String first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| String | second | The second text. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Hamming edit-distance measures the amount of substitutions between two texts. Because it does not handle insertions or deletions, the two texts are required to be the same length. It also does not handle transpositions, so a transposition will be counted as two substitutions. This is the simplest of all EditDistance algorithms, and is fast, but limited.
Levenshtein(Char*, Int32, Char*, Int32)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char*first, Int32 firstLength, Char*second, Int32 secondLength)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | firstLength | The length of the |
| Char* | second | The second text. |
| Int32 | secondLength | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char*, Int32, Char[])
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char*first, Int32 length, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char*, Int32, Memory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char*first, Int32 length, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char*, Int32, ReadOnlyMemory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char*first, Int32 length, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char*, Int32, ReadOnlySpan<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char*first, Int32 length, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char*, Int32, Span<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char*first, Int32 length, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char*, Int32, String)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char*first, Int32 length, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text. |
| Int32 | length | The length of the |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char[], Char*, Int32)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char[] first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char[], Char[])
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char[] first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char[], Memory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char[] first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char[], ReadOnlyMemory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char[] first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char[], ReadOnlySpan<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char[] first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char[], Span<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char[] first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Char[], String)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Char[] first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Memory<Char>, Char*, Int32)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Memory<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Memory<Char>, Char[])
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Memory<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Memory<Char>, Memory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Memory<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Memory<Char>, ReadOnlyMemory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Memory<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Memory<Char>, ReadOnlySpan<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Memory<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Memory<Char>, Span<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Memory<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Memory<Char>, String)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Memory<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlyMemory<Char>, Char*, Int32)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlyMemory<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlyMemory<Char>, Char[])
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlyMemory<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlyMemory<Char>, Memory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlyMemory<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlyMemory<Char>, ReadOnlyMemory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlyMemory<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlyMemory<Char>, ReadOnlySpan<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlyMemory<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlyMemory<Char>, Span<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlyMemory<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlyMemory<Char>, String)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlyMemory<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlySpan<Char>, Char*, Int32)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlySpan<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlySpan<Char>, Char[])
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlySpan<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlySpan<Char>, Memory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlySpan<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlySpan<Char>, ReadOnlyMemory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlySpan<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlySpan<Char>, ReadOnlySpan<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlySpan<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlySpan<Char>, Span<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlySpan<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(ReadOnlySpan<Char>, String)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(ReadOnlySpan<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Span<Char>, Char*, Int32)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Span<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Span<Char>, Char[])
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Span<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Span<Char>, Memory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Span<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Span<Char>, ReadOnlyMemory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Span<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Span<Char>, ReadOnlySpan<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Span<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Span<Char>, Span<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Span<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(Span<Char>, String)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(Span<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(String, Char*, Int32)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(String first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Char* | second | The second text. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(String, Char[])
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(String first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Char[] | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(String, Memory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(String first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Memory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(String, ReadOnlyMemory<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(String first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| ReadOnlyMemory<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(String, ReadOnlySpan<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(String first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| ReadOnlySpan<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(String, Span<Char>)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(String first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| Span<Char> | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.
Levenshtein(String, String)
Calculates the Levenshtein edit-distance between the first
and second
.
Declaration
public static Int32 Levenshtein(String first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text. |
| String | second | The second text. |
Returns
| Type | Description |
|---|---|
| Int32 | The number of edits to get from |
Remarks
Levenshtein edit-distance measures the amount of insertions, deletions, and substitutions, between two texts. Because it does not handle transpositions, a transposition will be counted as two substitutions. It can handle two texts of different lengths.