lib_ts_chainalign 2.1.0

A chaining-based sequence-to-sequence aligner that accounts for template switches
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

//! Functions for making tschainalign compatible with tsalign types.

use compact_genome::interface::alphabet::Alphabet;
use generic_a_star::cost::AStarCost;
use lib_tsalign::{
    a_star_aligner::template_switch_distance::TemplateSwitchDirection,
    config::TemplateSwitchConfig, costs::gap_affine::GapAffineAlignmentCostTable,
};

use crate::costs::{AlignmentCosts, GapAffineCosts, TsLimits};

impl<AlphabetType: Alphabet, Cost: AStarCost> From<TemplateSwitchConfig<AlphabetType, Cost>>
    for AlignmentCosts<Cost>
{
    fn from(value: TemplateSwitchConfig<AlphabetType, Cost>) -> Self {
        let value = &value;
        assert!(value.left_flank_length == 0 && value.right_flank_length == 0);

        let ts_base_cost = value.base_cost.qqr;
        assert_eq!(ts_base_cost, value.base_cost.qrr);
        assert_eq!(ts_base_cost, value.base_cost.rqr);
        assert_eq!(ts_base_cost, value.base_cost.rrr);

        Self {
            primary_costs: (&value.primary_edit_costs).into(),
            secondary_costs: value
                .secondary_edit_costs(TemplateSwitchDirection::Reverse)
                .into(),
            ts_base_cost,
            ts_limits: TsLimits {
                inter_jump_12: value.rq_qr_offset_costs.zero_range().unwrap(),
                intra_jump_12: value.rr_qq_offset_costs.zero_range().unwrap(),
                // tsalign costs do not support limiting this.
                jump_34: isize::MIN..isize::MAX,
                length_23: value.length_costs.zero_range().unwrap(),
                ancestor_gap: value.reverse_anti_primary_gap_costs.zero_range().unwrap(),
            },
        }
    }
}

impl<AlphabetType: Alphabet, Cost: AStarCost>
    From<&'_ GapAffineAlignmentCostTable<AlphabetType, Cost>> for GapAffineCosts<Cost>
{
    fn from(value: &GapAffineAlignmentCostTable<AlphabetType, Cost>) -> Self {
        assert_eq!(value.unique_match_cost(), Some(Cost::zero()));
        Self {
            substitution: value.unique_substitution_cost().unwrap(),
            gap_open: value.unique_gap_open_cost().unwrap(),
            gap_extend: value.unique_gap_extend_cost().unwrap(),
        }
    }
}

impl<AlphabetType: Alphabet, Cost: AStarCost> From<GapAffineAlignmentCostTable<AlphabetType, Cost>>
    for GapAffineCosts<Cost>
{
    fn from(value: GapAffineAlignmentCostTable<AlphabetType, Cost>) -> Self {
        (&value).into()
    }
}