oxeylyzer-core 0.1.2

Core library for Oxeylyzer, a keyboard layout analyzer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# oxeylyzer-core

`oxeylyzer-core` is the high-performance layout evaluation and generation engine behind the [Oxeylyzer](https://github.com/o-x-e-y/oxeylyzer) keyboard layout analyzer. It provides data structures and very performant cached algorithms for generating and scoring keyboard layouts.

## Features

- Heavy Focus on Performance: Uses integer-based character mappings and an extensively cached engine (`FastLayout`, `LayoutCache`) to evaluate about 12 million layout permutations every second on my Ryzen 7 thinkpad.
- Configurable Weights: Customizable penalties and rewards for different metrics.
- Corpus Processing: contains tools (`CorpusCleaner`) to clean out corpora and extract character, bigram, trigram and skip1, skip2 and skip3gram frequencies,
- Parallel Generation:  under the hood to scale layout optimization across all available CPU cores.

## Example Usage

Here is a basic example of how to initialize the core engine, load a layout, and compute its score.

```rust
use oxeylyzer_core::{
    generate::Oxeylyzer,
    weights::Config,
    data::Data,
    layout::Layout,
};

// 1. Load the optimization configuration and weights.
// This defines penalties for stretches, SFBs, max finger usage, etc.
let config = Config::with_defaults();

// 2. Load language frequency data from a processed corpus.
// (Assuming you have generated an "english.json" corpus previously)
let data = Data::load("static/language_data/english.json").unwrap();

// 3. Initialize the generator engine
let generator = Oxeylyzer::new(data, config);

// 4. Load a base layout from a `.dof` (libdof) format file.
let base_layout = Layout::load("static/layouts/qwerty.dof").unwrap();

// 5. Convert the standard layout into a FastLayout for cached generation and analysis.
let mut fast_layout = generator.fast_layout(&base_layout, &[]);

// 6. Score the layout!
let score = generator.score(&fast_layout);
println!("Score for QWERTY: {}", score);

// 7. Get detailed layout statistics (SFBs, stretches, rolls, etc.)
let stats = generator.get_layout_stats(&fast_layout);
println!("Same-finger bigrams (SFBs): {:.2}%", stats.sfb);
println!("Inrolls: {:.2}%", stats.trigram_stats.inrolls);

// 8. Generate a highly optimized layout based on the input layout
let optimized_layout = generator.generate(&fast_layout);
println!("Optimized layout:\n{}", optimized_layout.formatted_string());
```

## Creating a new Corpus

You can use the `CorpusCleaner` to process raw text into an optimized `Data` structure containing bigram and trigram frequencies.

```rust
use oxeylyzer_core::corpus_cleaner::CorpusCleaner;
use oxeylyzer_core::data::Data;

let raw_text = "This is a large text corpus that will be analyzed.";

let cleaner = CorpusCleaner::builder()
    .with_chars("abcdefghijklmnopqrstuvwxyz., ")
    .build()
    .unwrap();

// Clean the text and generate a Data object containing character/bigram/trigram frequencies
let mut data = cleaner.clean_corpus(raw_text.chars()).flatten().collect::<Data>();
```