### StringMetric Installation

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Instructions on how to add StringMetric as a dependency in your Swift Package Manager configuration.

```APIDOC
## Installation

Add StringMetric as a dependency in your Swift Package Manager configuration.

```swift
// Package.swift
import PackageDescription

let package = Package(
    name: "MyProject",
    dependencies: [
        .package(url: "https://github.com/autozimu/StringMetric.swift.git", from: "0.0.0")
    ],
    targets: [
        .target(name: "MyProject", dependencies: ["StringMetric"])
    ]
)
```
```

--------------------------------

### Calculate Normalized Most Frequent K Distance

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Use this method to get a normalized similarity score between 0 and 1, based on character frequency. It's useful for consistent comparisons across different string lengths. Ensure the StringMetric module is imported.

```swift
import StringMetric

// Compare research-related words
let research = "research".distanceNormalizedMostFrequentK(between: "seeking", k: 2)
print(research)  // => 0.267 (approximately)

// Night translations comparison
let night = "night".distanceNormalizedMostFrequentK(between: "nacht", k: 2)
print(night)  // => 0.2

// No common characters at all
let noCommon = "my".distanceNormalizedMostFrequentK(between: "a", k: 2)
print(noCommon)  // => 0.0

// Typo detection with normalized score
let typo = "research".distanceNormalizedMostFrequentK(between: "resarch", k: 2)
print(typo)  // => 0.467 (approximately)

// Perfect frequency match (same characters, same counts)
let perfect = "aaaaabbbb".distanceNormalizedMostFrequentK(between: "ababababa", k: 2)
print(perfect)  // => 1.0

// Longer words with some overlap
let words = "significant".distanceNormalizedMostFrequentK(between: "capabilities", k: 2)
print(words)  // => 0.261 (approximately)

// Using k=3 for broader character comparison
let broader = "aabbbcc".distanceNormalizedMostFrequentK(between: "bbccddee", k: 3)
print(broader)  // => 0.6
```

--------------------------------

### Calculate Jaro-Winkler Similarity with StringMetric

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Use the default distance method (alias for distanceJaroWinkler) to get a similarity score between 0 and 1. Handles Unicode characters.

```swift
import StringMetric

// Basic usage - comparing similar words
let similarity = "kitten".distance(between: "sitting")
print(similarity)  // => 0.746

// Exact match returns 1.0
let exactMatch = "hello".distance(between: "hello")
print(exactMatch)  // => 1.0

// No similarity returns 0.0
let noMatch = "search".distance(between: "find")
print(noMatch)  // => 0.0

// Works with Unicode/CJK characters
let chineseSimilarity = "君子和而不同".distance(between: "小人同而不和")
print(chineseSimilarity)  // => 0.555
```

--------------------------------

### Add StringMetric as Swift Package Manager Dependency

Source: https://github.com/autozimu/stringmetric.swift/blob/master/README.md

Integrate the StringMetric library into your project by adding its Git URL as a dependency in your Package.swift file.

```swift
.Package(url: "https://github.com/autozimu/StringMetric.swift.git", majorVersion: 0)
```

--------------------------------

### distanceNormalizedMostFrequentK(between:k:)

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Normalized Most Frequent K characters distance, returning a normalized similarity score between 0 (no similarity) and 1 (exact match based on character frequency). This is the normalized version of `distanceMostFreqK` and is useful when you need a consistent scale for comparison.

```APIDOC
## distanceNormalizedMostFrequentK(between:k:)

### Description
Calculates the Normalized Most Frequent K characters distance, returning a normalized similarity score between 0 (no similarity) and 1 (exact match based on character frequency). This is the normalized version of `distanceMostFreqK` and is useful when you need a consistent scale for comparison.

### Method
Extension on String

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```swift
import StringMetric

let similarity = "research".distanceNormalizedMostFrequentK(between: "seeking", k: 2)
print(similarity)
```

### Response
#### Success Response (200)
- **Double** - A normalized similarity score between 0.0 and 1.0.

#### Response Example
```json
{
  "similarity": 0.267
}
```

### Examples
```swift
// Compare research-related words
let research = "research".distanceNormalizedMostFrequentK(between: "seeking", k: 2)
print(research)  // => 0.267 (approximately)

// Night translations comparison
let night = "night".distanceNormalizedMostFrequentK(between: "nacht", k: 2)
print(night)  // => 0.2

// No common characters at all
let noCommon = "my".distanceNormalizedMostFrequentK(between: "a", k: 2)
print(noCommon)  // => 0.0

// Typo detection with normalized score
let typo = "research".distanceNormalizedMostFrequentK(between: "resarch", k: 2)
print(typo)  // => 0.467 (approximately)

// Perfect frequency match (same characters, same counts)
let perfect = "aaaaabbbb".distanceNormalizedMostFrequentK(between: "ababababa", k: 2)
print(perfect)  // => 1.0

// Longer words with some overlap
let words = "significant".distanceNormalizedMostFrequentK(between: "capabilities", k: 2)
print(words)  // => 0.261 (approximately)

// Using k=3 for broader character comparison
let broader = "aabbbcc".distanceNormalizedMostFrequentK(between: "bbccddee", k: 3)
print(broader)  // => 0.6
```
```

--------------------------------

### distance() - Jaro-Winkler Similarity

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

The default distance method that returns the Jaro-Winkler similarity score between two strings. This is an alias for `distanceJaroWinkler(between:)` and provides a normalized score where 0 means no similarity and 1 means an exact match.

```APIDOC
## distance(between:)

### Description
The default distance method that returns the Jaro-Winkler similarity score between two strings. This is an alias for `distanceJaroWinkler(between:)` and provides a normalized score where 0 means no similarity and 1 means an exact match.

### Method
`String.distance(between: String) -> Double`

### Endpoint
N/A (Extension Method)

### Parameters
#### Instance Parameters
- **self** (String) - The first string.
- **other** (String) - The second string to compare against.

### Request Example
```swift
import StringMetric

// Basic usage - comparing similar words
let similarity = "kitten".distance(between: "sitting")
print(similarity)  // => 0.746

// Exact match returns 1.0
let exactMatch = "hello".distance(between: "hello")
print(exactMatch)  // => 1.0

// No similarity returns 0.0
let noMatch = "search".distance(between: "find")
print(noMatch)  // => 0.0

// Works with Unicode/CJK characters
let chineseSimilarity = "君子和而不同".distance(between: "小人同而不和")
print(chineseSimilarity)  // => 0.555
```

### Response
#### Success Response (Double)
- **similarity_score** (Double) - The Jaro-Winkler similarity score between the two strings, ranging from 0.0 (no similarity) to 1.0 (exact match).
```

--------------------------------

### Calculate Hamming Distance Between Strings

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Hamming distance between two strings of equal length. Returns the number of positions where the corresponding characters differ. Both strings must have the same length or an assertion failure will occur.

```swift
import StringMetric

// Compare names - 3 positions differ
let names = "karolin".distanceHamming(between: "kathrin")
print(names)  // => 3

// Another name comparison
let names2 = "karolin".distanceHamming(between: "kerstin")
print(names2)  // => 3

// Binary string comparison
let binary = "1011101".distanceHamming(between: "1001001")
print(binary)  // => 2

// Numeric string comparison
let numbers = "2173896".distanceHamming(between: "2233796")
print(numbers)  // => 3

// Error detection example - comparing checksums
let checksum1 = "ABCDEF"
let checksum2 = "ABXDEY"
let errors = checksum1.distanceHamming(between: checksum2)
print("Bit errors detected: \(errors)")  // => Bit errors detected: 2
```

--------------------------------

### Jaro-Winkler Similarity

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Jaro-Winkler similarity score between two strings. Returns a normalized value between 0 (no similarity) and 1 (exact match). This algorithm gives higher scores to strings that match from the beginning, making it ideal for comparing names and short strings.

```APIDOC
## distanceJaroWinkler(between:)

### Description
Calculates the Jaro-Winkler similarity score between two strings. Returns a normalized value between 0 (no similarity) and 1 (exact match). This algorithm gives higher scores to strings that match from the beginning, making it ideal for comparing names and short strings.

### Method
Extension Method (String)

### Endpoint
N/A (Instance method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```swift
let exact = "search".distanceJaroWinkler(between: "search")
print(exact) // => 1.0
```

### Response
#### Success Response (Double)
- **similarityScore** (Double) - A value between 0.0 and 1.0 indicating the similarity.
```

--------------------------------

### Calculate Jaro-Winkler Similarity Score

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Jaro-Winkler similarity score between two strings, returning a normalized value between 0 (no similarity) and 1 (exact match). This algorithm favors strings that match from the beginning, making it suitable for comparing names and short strings.

```swift
import StringMetric

// Exact match
let exact = "search".distanceJaroWinkler(between: "search")
print(exact)  // => 1.0

// Both empty strings are considered identical
let bothEmpty = "".distanceJaroWinkler(between: "")
print(bothEmpty)  // => 1.0

// One empty string means no similarity
let oneEmpty = "".distanceJaroWinkler(between: "Yo")
print(oneEmpty)  // => 0.0

// No common characters
let noCommon = "search".distanceJaroWinkler(between: "find")
print(noCommon)  // => 0.0

// Classic examples from the algorithm's documentation
let martha = "MARTHA".distanceJaroWinkler(between: "MARHTA")
print(martha)  // => 0.961

let dwayne = "DWAYNE".distanceJaroWinkler(between: "DUANE")
print(dwayne)  // => 0.84

let dixon = "DIXON".distanceJaroWinkler(between: "DICKSONX")
print(dixon)  // => 0.814

// Common word comparison
let kitten = "kitten".distanceJaroWinkler(between: "sitting")
print(kitten)  // => 0.746

// Unicode/CJK support
let chinese = "君子和而不同".distanceJaroWinkler(between: "小人同而不和")
print(chinese)  // => 0.555
```

--------------------------------

### Calculate String Distance using Jaro-Winkler

Source: https://github.com/autozimu/stringmetric.swift/blob/master/README.md

Use the `distance` function, an alias for `distanceJaroWinkler`, to calculate the Jaro-Winkler distance between two strings. This is useful for comparing strings where character order and matches are important.

```swift
"kitten".distance(between: "sitting")    // => 0.746
```

```swift
"君子和而不同".distance(between: "小人同而不和")    // => 0.555
```

--------------------------------

### distanceLevenshtein(between:)

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Levenshtein distance (edit distance) between two strings. Returns the minimum number of single-character edits (insertions, deletions, or substitutions) required to transform one string into another.

```APIDOC
## distanceLevenshtein(between:)

### Description
Calculates the Levenshtein distance (edit distance) between two strings. Returns the minimum number of single-character edits (insertions, deletions, or substitutions) required to transform one string into another.

### Method
`String.distanceLevenshtein(between: String) -> Int`

### Endpoint
N/A (Extension Method)

### Parameters
#### Instance Parameters
- **self** (String) - The first string.
- **other** (String) - The second string to compare against.

### Request Example
```swift
import StringMetric

// "kitten" -> "sitting" requires 3 edits:
// kitten -> sitten (substitution of 's' for 'k')
// sitten -> sittin (substitution of 'i' for 'e')
// sittin -> sitting (insertion of 'g' at the end)
let distance = "kitten".distanceLevenshtein(between: "sitting")
print(distance)  // => 3

// "saturday" -> "sunday" requires 3 edits
let weekendDistance = "saturday".distanceLevenshtein(between: "sunday")
print(weekendDistance)  // => 3

// Empty string comparisons
let fromEmpty = "".distanceLevenshtein(between: "sitting")
print(fromEmpty)  // => 7 (length of target string)

let toEmpty = "kitten".distanceLevenshtein(between: "")
print(toEmpty)  // => 6 (length of source string)

// Unicode support
let chineseDistance = "君子和而不同".distanceLevenshtein(between: "小人同而不和")
print(chineseDistance)  // => 4
```

### Response
#### Success Response (Int)
- **edit_distance** (Int) - The Levenshtein distance between the two strings.
```

--------------------------------

### Calculate Levenshtein Distance with StringMetric

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Compute the Levenshtein distance (edit distance) between two strings, representing the minimum single-character edits needed for transformation. Supports Unicode.

```swift
import StringMetric

// "kitten" -> "sitting" requires 3 edits:
// kitten -> sitten (substitution of 's' for 'k')
// sitten -> sittin (substitution of 'i' for 'e')
// sittin -> sitting (insertion of 'g' at the end)
let distance = "kitten".distanceLevenshtein(between: "sitting")
print(distance)  // => 3

// "saturday" -> "sunday" requires 3 edits
let weekendDistance = "saturday".distanceLevenshtein(between: "sunday")
print(weekendDistance)  // => 3

// Empty string comparisons
let fromEmpty = "".distanceLevenshtein(between: "sitting")
print(fromEmpty)  // => 7 (length of target string)

let toEmpty = "kitten".distanceLevenshtein(between: "")
print(toEmpty)  // => 6 (length of source string)

// Unicode support
let chineseDistance = "君子和而不同".distanceLevenshtein(between: "小人同而不和")
print(chineseDistance)  // => 4
```

--------------------------------

### distanceDamerauLevenshtein(between:)

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Damerau-Levenshtein distance, which extends the Levenshtein distance by including transpositions (swapping two adjacent characters) as a single edit operation. This is particularly useful for detecting typos where adjacent characters are swapped.

```APIDOC
## distanceDamerauLevenshtein(between:)

### Description
Calculates the Damerau-Levenshtein distance, which extends the Levenshtein distance by including transpositions (swapping two adjacent characters) as a single edit operation. This is particularly useful for detecting typos where adjacent characters are swapped.

### Method
`String.distanceDamerauLevenshtein(between: String) -> Int`

### Endpoint
N/A (Extension Method)

### Parameters
#### Instance Parameters
- **self** (String) - The first string.
- **other** (String) - The second string to compare against.

### Request Example
```swift
import StringMetric

// Transposition: "CA" -> "AC" is 1 operation (swap)
// With regular Levenshtein this would be 2 (delete + insert)
let transposition = "CA".distanceDamerauLevenshtein(between: "AC")
print(transposition)  // => 1

// British vs American spelling with transposition
let spelling = "specter".distanceDamerauLevenshtein(between: "spectre")
print(spelling)  // => 1

// More complex example
let complex = "CA".distanceDamerauLevenshtein(between: "ABC")
print(complex)  // => 2

// Standard comparison similar to Levenshtein
let standard = "kitten".distanceDamerauLevenshtein(between: "sitting")
print(standard)  // => 3

// Empty string handling
let emptySource = "".distanceDamerauLevenshtein(between: "sitting")
print(emptySource)  // => 7

// Unicode support
let chinese = "君子和而不同".distanceDamerauLevenshtein(between: "小人同而不和")
print(chinese)  // => 4
```

### Response
#### Success Response (Int)
- **edit_distance** (Int) - The Damerau-Levenshtein distance between the two strings.
```

--------------------------------

### Calculate Damerau-Levenshtein Distance with StringMetric

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Compute the Damerau-Levenshtein distance, which includes transpositions (swapping adjacent characters) as a single edit. Useful for detecting typos. Supports Unicode.

```swift
import StringMetric

// Transposition: "CA" -> "AC" is 1 operation (swap)
// With regular Levenshtein this would be 2 (delete + insert)
let transposition = "CA".distanceDamerauLevenshtein(between: "AC")
print(transposition)  // => 1

// British vs American spelling with transposition
let spelling = "specter".distanceDamerauLevenshtein(between: "spectre")
print(spelling)  // => 1

// More complex example
let complex = "CA".distanceDamerauLevenshtein(between: "ABC")
print(complex)  // => 2

// Standard comparison similar to Levenshtein
let standard = "kitten".distanceDamerauLevenshtein(between: "sitting")
print(standard)  // => 3

// Empty string handling
let emptySource = "".distanceDamerauLevenshtein(between: "sitting")
print(emptySource)  // => 7

// Unicode support
let chinese = "君子和而不同".distanceDamerauLevenshtein(between: "小人同而不和")
print(chinese)  // => 4
```

--------------------------------

### Hamming Distance

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Hamming distance between two strings of equal length. Returns the number of positions where the corresponding characters differ. Note: Both strings must have the same length or an assertion failure will occur.

```APIDOC
## distanceHamming(between:)

### Description
Calculates the Hamming distance between two strings of equal length. Returns the number of positions where the corresponding characters differ.

### Method
Extension Method (String)

### Endpoint
N/A (Instance method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```swift
let names = "karolin".distanceHamming(between: "kathrin")
print(names) // => 3
```

### Response
#### Success Response (Int)
- **distance** (Int) - The number of positions where characters differ.
```

--------------------------------

### Most Frequent K Characters Distance

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Most Frequent K characters distance between two strings. This algorithm compares strings based on the frequency of their K most common characters. Returns an integer distance where lower values indicate higher similarity. The `maxDistance` parameter (default: 10) sets the upper bound.

```APIDOC
## distanceMostFreqK(between:K:maxDistance:)

### Description
Calculates the Most Frequent K characters distance between two strings. This algorithm compares strings based on the frequency of their K most common characters. Returns an integer distance where lower values indicate higher similarity. The `maxDistance` parameter (default: 10) sets the upper bound.

### Method
Extension Method (String)

### Endpoint
N/A (Instance method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```swift
let research = "research".distanceMostFreqK(between: "seeking", K: 2)
print(research) // => 8
```

### Response
#### Success Response (Int)
- **distance** (Int) - The calculated distance based on the frequency of the K most common characters.
```

--------------------------------

### Calculate Most Frequent K Characters Distance

Source: https://context7.com/autozimu/stringmetric.swift/llms.txt

Calculates the Most Frequent K characters distance between two strings. Compares strings based on the frequency of their K most common characters, returning an integer distance where lower values indicate higher similarity. The `maxDistance` parameter defaults to 10.

```swift
import StringMetric

// Compare similar research-related words
let research = "research".distanceMostFreqK(between: "seeking", K: 2)
print(research)  // => 8

// Compare "night" translations (English vs German "nacht")
let night = "night".distanceMostFreqK(between: "nacht", K: 2)
print(night)  // => 9

// Completely different short strings
let different = "my".distanceMostFreqK(between: "a", K: 2)
print(different)  // => 10 (maximum distance)

// Typo detection - "research" vs "resarch"
let typo = "research".distanceMostFreqK(between: "resarch", K: 2)
print(typo)  // => 6

// Strings with same characters but different arrangement
let anagram = "aaaaabbbb".distanceMostFreqK(between: "ababababa", K: 2)
print(anagram)  // => 1 (very similar frequency distribution)

// Longer word comparison
let words = "significant".distanceMostFreqK(between: "capabilities", K: 2)
print(words)  // => 7

// Using K=3 for more character consideration
let moreChars = "aabbbcc".distanceMostFreqK(between: "bbccddee", K: 3)
print(moreChars)  // => 5
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.