seqtree 0.0.3__tar.gz → 0.2.0__tar.gz

{seqtree-0.0.3 → seqtree-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: seqtree
-Version: 0.0.3
+Version: 0.2.0
 Summary: Fast fuzzy search over biological sequences (C++ core, Python bindings)
 Keywords: sequence-search,fuzzy-matching,CDR3,immunology,bioinformatics,trie
 Author-Email: ISALGO laboratory <mikhail.shugay@gmail.com>
@@ -35,9 +35,9 @@ Description-Content-Type: text/markdown
 
 [![PyPI](https://img.shields.io/pypi/v/seqtree.svg)](https://pypi.org/project/seqtree/)
 [![Python](https://img.shields.io/pypi/pyversions/seqtree.svg)](https://pypi.org/project/seqtree/)
-[![License](https://img.shields.io/pypi/l/seqtree.svg)](LICENSE)
+[![License](https://img.shields.io/badge/license-GPLv3-green)](LICENSE)
 [![CI](https://github.com/antigenomics/seqtree/actions/workflows/ci.yml/badge.svg)](https://github.com/antigenomics/seqtree/actions/workflows/ci.yml)
-[![Docs](https://github.com/antigenomics/seqtree/actions/workflows/docs.yml/badge.svg)](https://antigenomics.github.io/seqtree/)
+[![Docs](https://github.com/antigenomics/seqtree/actions/workflows/docs.yml/badge.svg?branch=dev)](https://antigenomics.github.io/seqtree/)
 
 Fast fuzzy search over biological sequences (amino-acid or nucleotide), as a C++
 core with a minimal Python binding. Build an immutable index once, then search
@@ -58,8 +58,14 @@ to their own payloads (V gene, MHC, counts) and filter.
 
 Beyond search, seqtree ships:
 
-- **Substitution matrices** — built-in `BLOSUM62` and `PAM50`, plus custom matrices via
-  `SubstitutionMatrix.from_similarity` (Gram-distance penalty `s(a,a)+s(b,b)−2·s(a,b)`).
+- **Substitution matrices** — built-in `identity`, `BLOSUM62`, `PAM250`, `PAM100`, and `structural`
+  — a **Miyazawa–Jernigan interaction-strength** matrix: each residue's strength `q(a)=mean_b e(a,b)`
+  is read off the MJ contact potential, so substitutions between residues of like interaction strength
+  are cheap. It separates strong (hydrophobic `F W C L Y M I V`) from weak (polar/charged
+  `S Q D E K`) interactors — the strong/weak-interactor axis of TCR-recognition models
+  ([Košmrlj et al., *PNAS* 2008](https://doi.org/10.1073/pnas.0808081105); MJ contact energies from
+  Miyazawa & Jernigan, *J Mol Biol* 1996) — letting dissimilar-but-chemically-equivalent loops align.
+  Plus custom matrices via `SubstitutionMatrix.from_similarity` (Gram penalty `s(a,a)+s(b,b)−2·s(a,b)`).
 - **E-values / significance** — calibrate hit counts against a background control repertoire
   (`load_control` + `evalues`), the TCRNET approach on a finite-sample footing. See the
   [E-value guide](https://antigenomics.github.io/seqtree/evalue.html).

{seqtree-0.0.3 → seqtree-0.2.0}/README.md

@@ -2,9 +2,9 @@
 
 [![PyPI](https://img.shields.io/pypi/v/seqtree.svg)](https://pypi.org/project/seqtree/)
 [![Python](https://img.shields.io/pypi/pyversions/seqtree.svg)](https://pypi.org/project/seqtree/)
-[![License](https://img.shields.io/pypi/l/seqtree.svg)](LICENSE)
+[![License](https://img.shields.io/badge/license-GPLv3-green)](LICENSE)
 [![CI](https://github.com/antigenomics/seqtree/actions/workflows/ci.yml/badge.svg)](https://github.com/antigenomics/seqtree/actions/workflows/ci.yml)
-[![Docs](https://github.com/antigenomics/seqtree/actions/workflows/docs.yml/badge.svg)](https://antigenomics.github.io/seqtree/)
+[![Docs](https://github.com/antigenomics/seqtree/actions/workflows/docs.yml/badge.svg?branch=dev)](https://antigenomics.github.io/seqtree/)
 
 Fast fuzzy search over biological sequences (amino-acid or nucleotide), as a C++
 core with a minimal Python binding. Build an immutable index once, then search
@@ -25,8 +25,14 @@ to their own payloads (V gene, MHC, counts) and filter.
 
 Beyond search, seqtree ships:
 
-- **Substitution matrices** — built-in `BLOSUM62` and `PAM50`, plus custom matrices via
-  `SubstitutionMatrix.from_similarity` (Gram-distance penalty `s(a,a)+s(b,b)−2·s(a,b)`).
+- **Substitution matrices** — built-in `identity`, `BLOSUM62`, `PAM250`, `PAM100`, and `structural`
+  — a **Miyazawa–Jernigan interaction-strength** matrix: each residue's strength `q(a)=mean_b e(a,b)`
+  is read off the MJ contact potential, so substitutions between residues of like interaction strength
+  are cheap. It separates strong (hydrophobic `F W C L Y M I V`) from weak (polar/charged
+  `S Q D E K`) interactors — the strong/weak-interactor axis of TCR-recognition models
+  ([Košmrlj et al., *PNAS* 2008](https://doi.org/10.1073/pnas.0808081105); MJ contact energies from
+  Miyazawa & Jernigan, *J Mol Biol* 1996) — letting dissimilar-but-chemically-equivalent loops align.
+  Plus custom matrices via `SubstitutionMatrix.from_similarity` (Gram penalty `s(a,a)+s(b,b)−2·s(a,b)`).
 - **E-values / significance** — calibrate hit counts against a background control repertoire
   (`load_control` + `evalues`), the TCRNET approach on a finite-sample footing. See the
   [E-value guide](https://antigenomics.github.io/seqtree/evalue.html).

{seqtree-0.0.3 → seqtree-0.2.0}/include/seqtree/seqtree.hpp

@@ -33,14 +33,15 @@ private:
 // Non-negative substitution penalties indexed by alphabet code; penalty(a,a)==0.
 class SubstitutionMatrix {
 public:
-    // Unit cost: 0 for a match, 1 for a mismatch.
+    // Unit cost: 0 for a match, 1 for a mismatch (this is the "identity" matrix).
     static SubstitutionMatrix unit(uint8_t size);
-    // BLOSUM62 converted to penalties; valid only for the AminoAcid codec order.
+    // Built-in amino-acid matrices (valid only for the AminoAcid codec order).
     static SubstitutionMatrix blosum62();
-    // PAM50 (EMBOSS EPAM50) converted to penalties; AminoAcid codec order.
-    static SubstitutionMatrix pam50();
-    // Convert a similarity matrix (row-major, size*size) to penalties via
-    // pen[a][b] = max(sim[a][a], sim[b][b]) - sim[a][b].
+    static SubstitutionMatrix pam250();   // EMBOSS EPAM250 (NCBI log-odds)
+    static SubstitutionMatrix pam100();   // EMBOSS EPAM100 (NCBI log-odds)
+    static SubstitutionMatrix structural();  // Miyazawa-Jernigan interaction-strength similarity
+    // Convert a similarity matrix (row-major, size*size) to penalties via the Gram /
+    // squared-distance transform pen[a][b] = sim[a][a] + sim[b][b] - 2*sim[a][b].
     static SubstitutionMatrix from_similarity(uint8_t size, const int32_t* sim);
 
     uint8_t size() const { return size_; }

{seqtree-0.0.3 → seqtree-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "seqtree"
-version = "0.0.3"
+version = "0.2.0"
 description = "Fast fuzzy search over biological sequences (C++ core, Python bindings)"
 readme = "README.md"
 requires-python = ">=3.10"

{seqtree-0.0.3 → seqtree-0.2.0}/src/_bindings.cpp

@@ -19,7 +19,7 @@ struct PyParams {
     int max_subs = 0, max_ins = 0, max_dels = 0, max_total_edits = 0;
     long max_penalty = 0;
     int gap_open = 1, gap_extend = 1;
-    std::string matrix;          // named builtin: "" (unit), "blosum62", "pam50"
+    std::string matrix;          // named builtin: "" (unit/identity), blosum62/pam250/pam100/structural
     std::optional<SubstitutionMatrix> matrix_obj;  // explicit/custom matrix (overrides name)
     std::optional<PositionalMatrix> pos_matrix_obj;  // per-position penalties (Hamming path)
     std::string engine = "auto"; // auto | seqtrie | seqtm
@@ -63,6 +63,25 @@ std::string alphabet_symbols(Alphabet a) {
     return s;
 }
 
+// Built-in matrix names. "identity" is the unit matrix (any alphabet); the rest are
+// amino-acid only. Keep this list in sync with the SubstitutionMatrix factories.
+constexpr const char* kMatrixNames = "'identity', 'BLOSUM62', 'PAM250', 'PAM100', 'structural'";
+
+bool is_matrix_name(const std::string& l) {
+    return l.empty() || l == "identity" || l == "blosum62" || l == "pam250"
+        || l == "pam100" || l == "structural";
+}
+
+SubstitutionMatrix named_matrix(const std::string& l, Alphabet a) {
+    if (l == "identity") return SubstitutionMatrix::unit(Codec(a).size());
+    if (a != Alphabet::AminoAcid)
+        throw py::value_error(l + " requires the amino-acid alphabet");
+    if (l == "blosum62") return SubstitutionMatrix::blosum62();
+    if (l == "pam250") return SubstitutionMatrix::pam250();
+    if (l == "pam100") return SubstitutionMatrix::pam100();
+    return SubstitutionMatrix::structural();  // l == "structural"
+}
+
 // Returns nullopt for unit cost; throws for an unknown name or alphabet mismatch.
 // An explicit matrix object (custom or built via SubstitutionMatrix factories) wins
 // over the named builtin; we only check that its size matches the alphabet.
@@ -74,26 +93,22 @@ std::optional<SubstitutionMatrix> make_matrix(const PyParams& pp, Alphabet a) {
     }
     if (pp.matrix.empty()) return std::nullopt;
     std::string l = lower(pp.matrix);
-    if (l == "blosum62" || l == "pam50") {
-        if (a != Alphabet::AminoAcid)
-            throw py::value_error(pp.matrix + " requires the amino-acid alphabet");
-        return l == "blosum62" ? SubstitutionMatrix::blosum62() : SubstitutionMatrix::pam50();
-    }
-    throw py::value_error("unknown matrix '" + pp.matrix +
-                          "' (use '', 'BLOSUM62', 'PAM50', or a SubstitutionMatrix)");
+    if (!is_matrix_name(l))
+        throw py::value_error("unknown matrix '" + pp.matrix + "' (use '', " +
+                              kMatrixNames + ", or a SubstitutionMatrix)");
+    return named_matrix(l, a);
 }
 
-// Accept either a builtin name ("", "blosum62", "pam50") or a SubstitutionMatrix.
+// Accept either a builtin name (see kMatrixNames) or a SubstitutionMatrix.
 void set_matrix(PyParams& p, const py::object& m) {
     p.matrix.clear();
     p.matrix_obj.reset();
     if (m.is_none()) return;
     if (py::isinstance<py::str>(m)) {
         std::string name = m.cast<std::string>();
-        std::string l = lower(name);
-        if (!(l.empty() || l == "blosum62" || l == "pam50"))
-            throw py::value_error("unknown matrix '" + name +
-                                  "' (use '', 'BLOSUM62', 'PAM50', or a SubstitutionMatrix)");
+        if (!is_matrix_name(lower(name)))
+            throw py::value_error("unknown matrix '" + name + "' (use '', " +
+                                  kMatrixNames + ", or a SubstitutionMatrix)");
         p.matrix = std::move(name);
     } else if (py::isinstance<SubstitutionMatrix>(m)) {
         p.matrix_obj = m.cast<SubstitutionMatrix>();
@@ -190,11 +205,14 @@ PYBIND11_MODULE(_core, m) {
 
     py::class_<SubstitutionMatrix>(m, "SubstitutionMatrix",
                                    "Non-negative substitution penalties (penalty(a,a)==0). Build a "
-                                   "named builtin (``blosum62``/``pam50``) or a custom one from a "
-                                   "similarity grid whose row/column order matches "
-                                   "``amino_acids()`` (or ``alphabet_symbols(alphabet)``).")
+                                   "named builtin (``blosum62``/``pam250``/``pam100``/``structural``, "
+                                   "or ``unit`` for identity) or a custom one from a similarity grid "
+                                   "whose row/column order matches ``amino_acids()`` (or "
+                                   "``alphabet_symbols(alphabet)``).")
         .def_static("blosum62", &SubstitutionMatrix::blosum62)
-        .def_static("pam50", &SubstitutionMatrix::pam50)
+        .def_static("pam250", &SubstitutionMatrix::pam250)
+        .def_static("pam100", &SubstitutionMatrix::pam100)
+        .def_static("structural", &SubstitutionMatrix::structural)
         .def_static("unit", &SubstitutionMatrix::unit, py::arg("size"))
         .def_static(
             "from_similarity",
@@ -214,6 +232,23 @@ PYBIND11_MODULE(_core, m) {
             "penalties via max(sim[a,a], sim[b,b]) - sim[a,b]. Row/column order must match the "
             "target alphabet's symbol order (see ``amino_acids()``).")
         .def("size", &SubstitutionMatrix::size)
+        .def(
+            "penalty",
+            [](const SubstitutionMatrix& self, const std::string& a, const std::string& b) {
+                if (a.size() != 1 || b.size() != 1)
+                    throw py::value_error("penalty() takes two single amino-acid characters");
+                static const std::string aa = alphabet_symbols(Alphabet::AminoAcid);
+                auto ia = aa.find(a[0]), ib = aa.find(b[0]);
+                if (ia == std::string::npos || ib == std::string::npos)
+                    throw py::value_error("unknown amino acid; expected one of " + aa);
+                if (ia >= self.size() || ib >= self.size())
+                    throw py::value_error("residue out of range for this matrix's alphabet");
+                return self.penalty(uint8_t(ia), uint8_t(ib));
+            },
+            py::arg("a"), py::arg("b"),
+            "Gram-distance substitution penalty between two amino acids: 0 when identical, "
+            "larger when more dissimilar (s(a,a)+s(b,b)-2 s(a,b)). Characters use the "
+            "``amino_acids()`` order.")
         .def("__repr__", [](const SubstitutionMatrix& s) {
             return "SubstitutionMatrix(size=" + std::to_string(s.size()) + ")";
         });
@@ -242,12 +277,12 @@ PYBIND11_MODULE(_core, m) {
           py::arg("alphabet") = "aa",
           "Symbols in code order for an alphabet; custom matrices must follow this order.");
     m.def("amino_acids", [] { return alphabet_symbols(Alphabet::AminoAcid); },
-          "The amino-acid symbol order used by BLOSUM62 / PAM50 and custom AA matrices.");
+          "The amino-acid symbol order used by the built-in matrices and custom AA matrices.");
 
     py::class_<PyParams>(m, "SearchParams",
                          "Search scope and budget. Scope: max_subs/max_ins/max_dels (exact, "
                          "seqtm) and max_total_edits. Budget: max_penalty with an optional "
-                         "matrix ('BLOSUM62') and gap costs. engine is 'auto'|'seqtrie'|'seqtm', "
+                         "matrix (identity/BLOSUM62/PAM250/PAM100/structural) and gap costs. engine is 'auto'|'seqtrie'|'seqtm', "
                          "mode is 'all'|'top'.")
         .def(py::init([](int max_subs, int max_ins, int max_dels, int max_total_edits,
                          long max_penalty, py::object matrix, int gap_open, int gap_extend,

seqtree-0.2.0/src/pam100.inc

@@ -0,0 +1,31 @@
+// PAM100 (EMBOSS EPAM100, NCBI log-odds; similarity).
+// Row/column order: A R N D C Q E G H I L K M F P S T W Y V B Z X *
+// Generated by bench/gen_matrices.py -- do not edit by hand.
+static const int32_t kPam100Size = 24;
+static const int32_t kPam100[24 * 24] = {
+//    A    R    N    D    C    Q    E    G    H    I    L    K    M    F    P    S    T    W    Y    V    B    Z    X    *
+      4,  -3,  -1,  -1,  -3,  -2,   0,   1,  -3,  -2,  -3,  -3,  -2,  -5,   1,   1,   1,  -7,  -4,   0,  -1,  -1,  -1,  -9,
+     -3,   7,  -2,  -4,  -5,   1,  -3,  -5,   1,  -3,  -5,   2,  -1,  -6,  -1,  -1,  -3,   1,  -6,  -4,  -3,  -1,  -2,  -9,
+     -1,  -2,   5,   3,  -5,  -1,   1,  -1,   2,  -3,  -4,   1,  -4,  -5,  -2,   1,   0,  -5,  -2,  -3,   4,   0,  -1,  -9,
+     -1,  -4,   3,   5,  -7,   0,   4,  -1,  -1,  -4,  -6,  -1,  -5,  -8,  -3,  -1,  -2,  -9,  -6,  -4,   4,   3,  -2,  -9,
+     -3,  -5,  -5,  -7,   9,  -8,  -8,  -5,  -4,  -3,  -8,  -8,  -7,  -7,  -4,  -1,  -4,  -9,  -1,  -3,  -6,  -8,  -5,  -9,
+     -2,   1,  -1,   0,  -8,   6,   2,  -3,   3,  -4,  -2,   0,  -2,  -7,  -1,  -2,  -2,  -7,  -6,  -3,   0,   5,  -2,  -9,
+      0,  -3,   1,   4,  -8,   2,   5,  -1,  -1,  -3,  -5,  -1,  -4,  -8,  -2,  -1,  -2,  -9,  -5,  -3,   3,   4,  -2,  -9,
+      1,  -5,  -1,  -1,  -5,  -3,  -1,   5,  -4,  -5,  -6,  -3,  -4,  -6,  -2,   0,  -2,  -9,  -7,  -3,  -1,  -2,  -2,  -9,
+     -3,   1,   2,  -1,  -4,   3,  -1,  -4,   7,  -4,  -3,  -2,  -4,  -3,  -1,  -2,  -3,  -4,  -1,  -3,   1,   1,  -2,  -9,
+     -2,  -3,  -3,  -4,  -3,  -4,  -3,  -5,  -4,   6,   1,  -3,   1,   0,  -4,  -3,   0,  -7,  -3,   3,  -3,  -3,  -2,  -9,
+     -3,  -5,  -4,  -6,  -8,  -2,  -5,  -6,  -3,   1,   6,  -4,   3,   0,  -4,  -4,  -3,  -3,  -3,   0,  -5,  -4,  -3,  -9,
+     -3,   2,   1,  -1,  -8,   0,  -1,  -3,  -2,  -3,  -4,   5,   0,  -7,  -3,  -1,  -1,  -6,  -6,  -4,   0,  -1,  -2,  -9,
+     -2,  -1,  -4,  -5,  -7,  -2,  -4,  -4,  -4,   1,   3,   0,   9,  -1,  -4,  -3,  -1,  -6,  -5,   1,  -4,  -2,  -2,  -9,
+     -5,  -6,  -5,  -8,  -7,  -7,  -8,  -6,  -3,   0,   0,  -7,  -1,   8,  -6,  -4,  -5,  -1,   4,  -3,  -6,  -7,  -4,  -9,
+      1,  -1,  -2,  -3,  -4,  -1,  -2,  -2,  -1,  -4,  -4,  -3,  -4,  -6,   7,   0,  -1,  -7,  -7,  -3,  -3,  -1,  -2,  -9,
+      1,  -1,   1,  -1,  -1,  -2,  -1,   0,  -2,  -3,  -4,  -1,  -3,  -4,   0,   4,   2,  -3,  -4,  -2,   0,  -2,  -1,  -9,
+      1,  -3,   0,  -2,  -4,  -2,  -2,  -2,  -3,   0,  -3,  -1,  -1,  -5,  -1,   2,   5,  -7,  -4,   0,  -1,  -2,  -1,  -9,
+     -7,   1,  -5,  -9,  -9,  -7,  -9,  -9,  -4,  -7,  -3,  -6,  -6,  -1,  -7,  -3,  -7,  12,  -2,  -9,  -6,  -8,  -6,  -9,
+     -4,  -6,  -2,  -6,  -1,  -6,  -5,  -7,  -1,  -3,  -3,  -6,  -5,   4,  -7,  -4,  -4,  -2,   9,  -4,  -4,  -6,  -4,  -9,
+      0,  -4,  -3,  -4,  -3,  -3,  -3,  -3,  -3,   3,   0,  -4,   1,  -3,  -3,  -2,   0,  -9,  -4,   5,  -4,  -3,  -2,  -9,
+     -1,  -3,   4,   4,  -6,   0,   3,  -1,   1,  -3,  -5,   0,  -4,  -6,  -3,   0,  -1,  -6,  -4,  -4,   4,   2,  -2,  -9,
+     -1,  -1,   0,   3,  -8,   5,   4,  -2,   1,  -3,  -4,  -1,  -2,  -7,  -1,  -2,  -2,  -8,  -6,  -3,   2,   5,  -2,  -9,
+     -1,  -2,  -1,  -2,  -5,  -2,  -2,  -2,  -2,  -2,  -3,  -2,  -2,  -4,  -2,  -1,  -1,  -6,  -4,  -2,  -2,  -2,  -2,  -9,
+     -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,  -9,   1,
+};

seqtree-0.2.0/src/pam250.inc

@@ -0,0 +1,31 @@
+// PAM250 (EMBOSS EPAM250, NCBI log-odds; similarity).
+// Row/column order: A R N D C Q E G H I L K M F P S T W Y V B Z X *
+// Generated by bench/gen_matrices.py -- do not edit by hand.
+static const int32_t kPam250Size = 24;
+static const int32_t kPam250[24 * 24] = {
+//    A    R    N    D    C    Q    E    G    H    I    L    K    M    F    P    S    T    W    Y    V    B    Z    X    *
+      2,  -2,   0,   0,  -2,   0,   0,   1,  -1,  -1,  -2,  -1,  -1,  -3,   1,   1,   1,  -6,  -3,   0,   0,   0,   0,  -8,
+     -2,   6,   0,  -1,  -4,   1,  -1,  -3,   2,  -2,  -3,   3,   0,  -4,   0,   0,  -1,   2,  -4,  -2,  -1,   0,  -1,  -8,
+      0,   0,   2,   2,  -4,   1,   1,   0,   2,  -2,  -3,   1,  -2,  -3,   0,   1,   0,  -4,  -2,  -2,   2,   1,   0,  -8,
+      0,  -1,   2,   4,  -5,   2,   3,   1,   1,  -2,  -4,   0,  -3,  -6,  -1,   0,   0,  -7,  -4,  -2,   3,   3,  -1,  -8,
+     -2,  -4,  -4,  -5,  12,  -5,  -5,  -3,  -3,  -2,  -6,  -5,  -5,  -4,  -3,   0,  -2,  -8,   0,  -2,  -4,  -5,  -3,  -8,
+      0,   1,   1,   2,  -5,   4,   2,  -1,   3,  -2,  -2,   1,  -1,  -5,   0,  -1,  -1,  -5,  -4,  -2,   1,   3,  -1,  -8,
+      0,  -1,   1,   3,  -5,   2,   4,   0,   1,  -2,  -3,   0,  -2,  -5,  -1,   0,   0,  -7,  -4,  -2,   3,   3,  -1,  -8,
+      1,  -3,   0,   1,  -3,  -1,   0,   5,  -2,  -3,  -4,  -2,  -3,  -5,   0,   1,   0,  -7,  -5,  -1,   0,   0,  -1,  -8,
+     -1,   2,   2,   1,  -3,   3,   1,  -2,   6,  -2,  -2,   0,  -2,  -2,   0,  -1,  -1,  -3,   0,  -2,   1,   2,  -1,  -8,
+     -1,  -2,  -2,  -2,  -2,  -2,  -2,  -3,  -2,   5,   2,  -2,   2,   1,  -2,  -1,   0,  -5,  -1,   4,  -2,  -2,  -1,  -8,
+     -2,  -3,  -3,  -4,  -6,  -2,  -3,  -4,  -2,   2,   6,  -3,   4,   2,  -3,  -3,  -2,  -2,  -1,   2,  -3,  -3,  -1,  -8,
+     -1,   3,   1,   0,  -5,   1,   0,  -2,   0,  -2,  -3,   5,   0,  -5,  -1,   0,   0,  -3,  -4,  -2,   1,   0,  -1,  -8,
+     -1,   0,  -2,  -3,  -5,  -1,  -2,  -3,  -2,   2,   4,   0,   6,   0,  -2,  -2,  -1,  -4,  -2,   2,  -2,  -2,  -1,  -8,
+     -3,  -4,  -3,  -6,  -4,  -5,  -5,  -5,  -2,   1,   2,  -5,   0,   9,  -5,  -3,  -3,   0,   7,  -1,  -4,  -5,  -2,  -8,
+      1,   0,   0,  -1,  -3,   0,  -1,   0,   0,  -2,  -3,  -1,  -2,  -5,   6,   1,   0,  -6,  -5,  -1,  -1,   0,  -1,  -8,
+      1,   0,   1,   0,   0,  -1,   0,   1,  -1,  -1,  -3,   0,  -2,  -3,   1,   2,   1,  -2,  -3,  -1,   0,   0,   0,  -8,
+      1,  -1,   0,   0,  -2,  -1,   0,   0,  -1,   0,  -2,   0,  -1,  -3,   0,   1,   3,  -5,  -3,   0,   0,  -1,   0,  -8,
+     -6,   2,  -4,  -7,  -8,  -5,  -7,  -7,  -3,  -5,  -2,  -3,  -4,   0,  -6,  -2,  -5,  17,   0,  -6,  -5,  -6,  -4,  -8,
+     -3,  -4,  -2,  -4,   0,  -4,  -4,  -5,   0,  -1,  -1,  -4,  -2,   7,  -5,  -3,  -3,   0,  10,  -2,  -3,  -4,  -2,  -8,
+      0,  -2,  -2,  -2,  -2,  -2,  -2,  -1,  -2,   4,   2,  -2,   2,  -1,  -1,  -1,   0,  -6,  -2,   4,  -2,  -2,  -1,  -8,
+      0,  -1,   2,   3,  -4,   1,   3,   0,   1,  -2,  -3,   1,  -2,  -4,  -1,   0,   0,  -5,  -3,  -2,   3,   2,  -1,  -8,
+      0,   0,   1,   3,  -5,   3,   3,   0,   2,  -2,  -3,   0,  -2,  -5,   0,   0,  -1,  -6,  -4,  -2,   2,   3,  -1,  -8,
+      0,  -1,   0,  -1,  -3,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -2,  -1,   0,   0,  -4,  -2,  -1,  -1,  -1,  -1,  -8,
+     -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,   1,
+};

seqtree-0.2.0/src/structural.inc

@@ -0,0 +1,31 @@
+// Miyazawa-Jernigan interaction-strength similarity (strong/weak interactors; 0..10).
+// Row/column order: A R N D C Q E G H I L K M F P S T W Y V B Z X *
+// Generated by bench/gen_matrices.py -- do not edit by hand.
+static const int32_t kStructuralSize = 24;
+static const int32_t kStructural[24 * 24] = {
+//    A    R    N    D    C    Q    E    G    H    I    L    K    M    F    P    S    T    W    Y    V    B    Z    X    *
+     10,   9,   9,   7,   6,   8,   7,  10,   9,   6,   6,   5,   6,   5,   9,   8,   9,   6,   6,   7,   8,   7,   7,   0,
+      9,  10,  10,   8,   4,   9,   8,   8,   8,   5,   4,   6,   5,   4,  10,  10,   9,   4,   5,   6,   9,   9,   7,   0,
+      9,  10,  10,   8,   4,   9,   8,   8,   8,   5,   4,   6,   5,   4,  10,  10,   9,   4,   5,   6,   9,   9,   7,   0,
+      7,   8,   8,  10,   3,   9,  10,   7,   6,   3,   3,   8,   3,   2,   8,   9,   8,   3,   3,   4,   9,   9,   6,   0,
+      6,   4,   4,   3,  10,   4,   2,   6,   7,   9,  10,   1,   9,   9,   4,   4,   5,  10,  10,   8,   4,   3,   6,   0,
+      8,   9,   9,   9,   4,  10,   9,   8,   7,   4,   4,   7,   4,   3,   9,  10,   9,   3,   4,   5,   9,   9,   7,   0,
+      7,   8,   8,  10,   2,   9,  10,   6,   6,   3,   2,   8,   3,   2,   8,   8,   7,   2,   3,   4,   9,   9,   6,   0,
+     10,   8,   8,   7,   6,   8,   6,  10,   9,   7,   6,   5,   6,   5,   8,   8,   9,   6,   6,   8,   8,   7,   7,   0,
+      9,   8,   8,   6,   7,   7,   6,   9,  10,   7,   7,   4,   7,   6,   8,   7,   8,   6,   7,   8,   7,   6,   7,   0,
+      6,   5,   5,   3,   9,   4,   3,   7,   7,  10,   9,   1,  10,   9,   5,   5,   6,   9,  10,   9,   4,   4,   7,   0,
+      6,   4,   4,   3,  10,   4,   2,   6,   7,   9,  10,   1,  10,   9,   4,   4,   5,  10,  10,   8,   4,   3,   6,   0,
+      5,   6,   6,   8,   1,   7,   8,   5,   4,   1,   1,  10,   1,   0,   6,   6,   6,   0,   1,   2,   7,   8,   4,   0,
+      6,   5,   5,   3,   9,   4,   3,   6,   7,  10,  10,   1,  10,   9,   5,   5,   5,   9,  10,   9,   4,   4,   7,   0,
+      5,   4,   4,   2,   9,   3,   2,   5,   6,   9,   9,   0,   9,  10,   4,   4,   4,  10,   9,   8,   3,   2,   6,   0,
+      9,  10,  10,   8,   4,   9,   8,   8,   8,   5,   4,   6,   5,   4,  10,  10,   9,   4,   5,   6,   9,   9,   7,   0,
+      8,  10,  10,   9,   4,  10,   8,   8,   7,   5,   4,   6,   5,   4,  10,  10,   9,   4,   4,   6,   9,   9,   7,   0,
+      9,   9,   9,   8,   5,   9,   7,   9,   8,   6,   5,   6,   5,   4,   9,   9,  10,   5,   5,   7,   9,   8,   7,   0,
+      6,   4,   4,   3,  10,   3,   2,   6,   6,   9,  10,   0,   9,  10,   4,   4,   5,  10,   9,   8,   3,   3,   6,   0,
+      6,   5,   5,   3,  10,   4,   3,   6,   7,  10,  10,   1,  10,   9,   5,   4,   5,   9,  10,   9,   4,   3,   6,   0,
+      7,   6,   6,   4,   8,   5,   4,   8,   8,   9,   8,   2,   9,   8,   6,   6,   7,   8,   9,  10,   5,   5,   7,   0,
+      8,   9,   9,   9,   4,   9,   9,   8,   7,   4,   4,   7,   4,   3,   9,   9,   9,   3,   4,   5,   9,   9,   7,   0,
+      7,   9,   9,   9,   3,   9,   9,   7,   6,   4,   3,   8,   4,   2,   9,   9,   8,   3,   3,   5,   9,   9,   6,   0,
+      7,   7,   7,   6,   6,   7,   6,   7,   7,   7,   6,   4,   7,   6,   7,   7,   7,   6,   6,   7,   7,   6,   7,   0,
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  10,
+};

{seqtree-0.0.3 → seqtree-0.2.0}/src/substitution_matrix.cpp

@@ -3,7 +3,9 @@
 namespace seqtree {
 
 #include "blosum62.inc"
-#include "pam50.inc"
+#include "pam250.inc"
+#include "pam100.inc"
+#include "structural.inc"
 
 SubstitutionMatrix SubstitutionMatrix::unit(uint8_t size) {
     SubstitutionMatrix m;
@@ -34,8 +36,16 @@ SubstitutionMatrix SubstitutionMatrix::blosum62() {
     return from_similarity(static_cast<uint8_t>(kBlosum62Size), kBlosum62);
 }
 
-SubstitutionMatrix SubstitutionMatrix::pam50() {
-    return from_similarity(static_cast<uint8_t>(kPam50Size), kPam50);
+SubstitutionMatrix SubstitutionMatrix::pam250() {
+    return from_similarity(static_cast<uint8_t>(kPam250Size), kPam250);
+}
+
+SubstitutionMatrix SubstitutionMatrix::pam100() {
+    return from_similarity(static_cast<uint8_t>(kPam100Size), kPam100);
+}
+
+SubstitutionMatrix SubstitutionMatrix::structural() {
+    return from_similarity(static_cast<uint8_t>(kStructuralSize), kStructural);
 }
 
 }  // namespace seqtree

seqtree-0.0.3/src/pam50.inc

@@ -1,32 +0,0 @@
-// PAM50 substitution scores (similarity, higher = more similar).
-// Row/column order: A R N D C Q E G H I L K M F P S T W Y V B Z X *
-// EMBOSS EPAM50 (PAM 50, scale = ln(2)/2). Converted to non-negative penalties at load.
-// Generated by bench/gen_pam50.py -- do not edit by hand.
-static const int32_t kPam50Size = 24;
-static const int32_t kPam50[24 * 24] = {
-//    A    R    N    D    C    Q    E    G    H    I    L    K    M    F    P    S    T    W    Y    V    B    Z    X    *
-      5,  -5,  -2,  -2,  -5,  -3,  -1,  -1,  -5,  -3,  -5,  -5,  -4,  -7,   0,   0,   0, -11,  -6,  -1,  -2,  -2,  -2, -13,
-     -5,   8,  -4,  -7,  -6,   0,  -7,  -7,   0,  -4,  -7,   1,  -3,  -8,  -3,  -2,  -5,  -1,  -8,  -6,  -5,  -2,  -4, -13,
-     -2,  -4,   7,   2,  -8,  -2,  -1,  -2,   1,  -4,  -6,   0,  -6,  -7,  -4,   1,  -1,  -7,  -3,  -6,   5,  -1,  -2, -13,
-     -2,  -7,   2,   7, -11,  -1,   3,  -2,  -2,  -6, -10,  -3,  -8, -12,  -6,  -2,  -3, -12,  -9,  -6,   6,   2,  -4, -13,
-     -5,  -6,  -8, -11,   9, -11, -11,  -7,  -6,  -5, -12, -11, -11, -10,  -6,  -2,  -6, -13,  -3,  -5,  -9, -11,  -7, -13,
-     -3,   0,  -2,  -1, -11,   8,   2,  -5,   2,  -6,  -4,  -2,  -3, -10,  -2,  -4,  -4, -10,  -9,  -5,  -2,   6,  -3, -13,
-     -1,  -7,  -1,   3, -11,   2,   7,  -3,  -3,  -4,  -7,  -3,  -5, -11,  -4,  -3,  -4, -13,  -7,  -5,   2,   6,  -3, -13,
-     -1,  -7,  -2,  -2,  -7,  -5,  -3,   6,  -7,  -8,  -9,  -6,  -7,  -8,  -4,  -1,  -4, -12, -11,  -4,  -2,  -4,  -4, -13,
-     -5,   0,   1,  -2,  -6,   2,  -3,  -7,   9,  -7,  -5,  -4,  -8,  -5,  -3,  -4,  -5,  -6,  -2,  -5,   0,   0,  -4, -13,
-     -3,  -4,  -4,  -6,  -5,  -6,  -4,  -8,  -7,   8,   0,  -5,   0,  -1,  -7,  -5,  -1, -11,  -5,   3,  -5,  -5,  -3, -13,
-     -5,  -7,  -6, -10, -12,  -4,  -7,  -9,  -5,   0,   6,  -6,   2,  -1,  -6,  -7,  -5,  -5,  -5,  -1,  -7,  -5,  -5, -13,
-     -5,   1,   0,  -3, -11,  -2,  -3,  -6,  -4,  -5,  -6,   6,  -1, -11,  -5,  -3,  -2,  -9,  -8,  -7,  -1,  -2,  -4, -13,
-     -4,  -3,  -6,  -8, -11,  -3,  -5,  -7,  -8,   0,   2,  -1,  10,  -3,  -6,  -4,  -3, -10,  -8,   0,  -7,  -4,  -4, -13,
-     -7,  -8,  -7, -12, -10, -10, -11,  -8,  -5,  -1,  -1, -11,  -3,   9,  -8,  -5,  -7,  -3,   3,  -6,  -9, -11,  -6, -13,
-      0,  -3,  -4,  -6,  -6,  -2,  -4,  -4,  -3,  -7,  -6,  -5,  -6,  -8,   8,  -1,  -3, -11, -11,  -4,  -5,  -3,  -4, -13,
-      0,  -2,   1,  -2,  -2,  -4,  -3,  -1,  -4,  -5,  -7,  -3,  -4,  -5,  -1,   6,   1,  -4,  -5,  -4,  -1,  -3,  -2, -13,
-      0,  -5,  -1,  -3,  -6,  -4,  -4,  -4,  -5,  -1,  -5,  -2,  -3,  -7,  -3,   1,   6, -10,  -5,  -2,  -2,  -4,  -2, -13,
-    -11,  -1,  -7, -12, -13, -10, -13, -12,  -6, -11,  -5,  -9, -10,  -3, -11,  -4, -10,  13,  -4, -12,  -8, -11,  -9, -13,
-     -6,  -8,  -3,  -9,  -3,  -9,  -7, -11,  -2,  -5,  -5,  -8,  -8,   3, -11,  -5,  -5,  -4,   9,  -6,  -5,  -8,  -6, -13,
-     -1,  -6,  -6,  -6,  -5,  -5,  -5,  -4,  -5,   3,  -1,  -7,   0,  -6,  -4,  -4,  -2, -12,  -6,   7,  -6,  -5,  -3, -13,
-     -2,  -5,   5,   6,  -9,  -2,   2,  -2,   0,  -5,  -7,  -1,  -7,  -9,  -5,  -1,  -2,  -8,  -5,  -6,   5,   1,  -3, -13,
-     -2,  -2,  -1,   2, -11,   6,   6,  -4,   0,  -5,  -5,  -2,  -4, -11,  -3,  -3,  -4, -11,  -8,  -5,   1,   6,  -3, -13,
-     -2,  -4,  -2,  -4,  -7,  -3,  -3,  -4,  -4,  -3,  -5,  -4,  -4,  -6,  -4,  -2,  -2,  -9,  -6,  -3,  -3,  -3,  -4, -13,
-    -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13,   1,
-};