hdlib 2.1.0__py3-none-any.whl

hdlib-2.1.0.data/scripts/chopin2.py

@@ -0,0 +1,473 @@
+#!python
+"""Implementation of chopin2 ML model with hdlib."""
+
+__author__ = ("Fabio Cumbo (fabio.cumbo@gmail.com)")
+
+__version__ = "1.1.1"
+__date__ = "Nov 7, 2025"
+
+import argparse as ap
+import contextlib
+import errno
+import os
+import statistics
+import time
+from typing import List, Tuple
+
+import numpy as np
+from sklearn.metrics import accuracy_score, confusion_matrix, f1_score, matthews_corrcoef, precision_score, recall_score
+from tabulate import tabulate
+
+from hdlib.model import ClassificationModel
+
+
+def read_params():
+    """Read and test the input arguments.
+
+    Returns
+    -------
+    argparse.ArgumentParser
+        The ArgumentParser object
+    """
+
+    p = ap.ArgumentParser(
+        prog="chopin2",
+        description="chopin2 powered by hdlib",
+        formatter_class=ap.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument(
+        "--input",
+        type=os.path.abspath,
+        required=True,
+        help="Path to the input matrix",
+    )
+    p.add_argument(
+        "--fieldsep",
+        type=str,
+        default="\t",
+        help="Input field separator",
+    )
+    p.add_argument(
+        "--dimensionality",
+        type=int,
+        default=10000,
+        help="Vectors dimensionality",
+    )
+    p.add_argument(
+        "--levels",
+        type=int,
+        required=True,
+        help="Number of HD levels",
+    )
+    p.add_argument(
+        "--kfolds",
+        type=int,
+        default=0,
+        help="Number of folds for cross-validating the classification model",
+    )
+    p.add_argument(
+        "--test-percentage",
+        type=float,
+        default=0.0,
+        dest="test_percentage",
+        help="Percentage of data points for defining the test set",
+    )
+    p.add_argument(
+        "--feature-selection",
+        type=str.lower,
+        choices=["forward", "backward"],
+        dest="feature_selection",
+        help="Run the feature selection and report a ranking of features based on their importance",
+    )
+    p.add_argument(
+        "--retrain",
+        type=int,
+        default=0,
+        help="Number of retraining iterations",
+    )
+    p.add_argument(
+        "--threshold",
+        type=float,
+        default=0.6,
+        help="Threshold on the accuracy score. Used in conjunction with --feature-selection",
+    )
+    p.add_argument(
+        "--uncertainty",
+        type=float,
+        default=5.0,
+        help="Uncertainty percentage. Used in conjunction with --feature-selection",
+    )
+    p.add_argument(
+        "--nproc",
+        type=int,
+        default=1,
+        help="Make it parallel when possible",
+    )
+    p.add_argument(
+        "--output",
+        type=os.path.abspath,
+        default=None,
+        help="Path to the output file (full path). If not specified, output is printed to stdout",
+    )
+    p.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version="chopin2 (hdlib) version {} ({})".format(__version__, __date__),
+        help="Print the tool version and exit",
+    )
+
+    return p.parse_args()
+
+
+def load_dataset(filepath: os.path.abspath, sep: str="\t") -> Tuple[List[str], List[List[float]], List[str]]:
+    """Load the input numerical dataset.
+
+    Parameters
+    ----------
+    filepath : str
+        Path to the input dataset.
+    sep : str
+        Filed separator for the input dataset.
+
+    Returns
+    -------
+    tuple
+        A tuple with a list of sample IDs, a list of features, a list of lists with the
+        actual numerical data (floats), and a list with class labels.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the input file does not exist.
+    ValueError
+        If the input dataset does not contain number only.
+    """
+
+    if not os.path.isfile(filepath):
+        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), filepath)
+
+    samples = list()
+    content = list()
+    classes = list()
+
+    try:
+        with open(filepath) as infile:
+            # Trip the first and last column out
+            features = infile.readline().rstrip().split(sep)[1:-1]
+
+            for line in infile:
+                line = line.strip()
+
+                if line and not line.startswith("#"):
+                    line_split = line.split(sep)
+
+                    # Add sample ID
+                    samples.append(line_split[0])
+
+                    row_data = [float(value) for value in line_split[1:-1]]
+
+                    # Add row
+                    content.append(row_data)
+
+                    # Take track of the class
+                    classes.append(line_split[-1])
+
+    except ValueError as e:
+        raise Exception("The input dataset must contain numbers only!").with_traceback(e.__traceback__)
+
+    return samples, features, content, classes
+
+
+def percentage_split(labels: List[str], percentage: float, seed: int=0) -> List[int]:
+    """Given list of classes as appear in the original dataset and a percentage number, split a dataset and 
+    report the indices of the selected data points.
+
+    Parameters
+    ----------
+    labels : list
+        List of class labels as they appear in the original dataset.
+    percentage : float
+        Percentage of points to split out of the original dataset.
+    seed : int
+        Random seed for reproducing the same results.
+
+    Returns
+    -------
+    list
+        A list with the indices of selected points.
+
+    Raises
+    ------
+    ValueError
+        - if the input `percentage` is lower than or equal to 0.0 or greater than 100.0;
+        - if the input `seed` is not an integer number.
+
+    Examples
+    --------
+    >>> from hdlib.parser import percentage_split
+    >>> labels = [1, 2, 2, 2, 1, 1, 1, 1, 2, 2]
+    >>> percentage_split(labels, 20.0, seed=0)
+    [6, 9]
+
+    Consider a dataset with 10 data points, select 20% of the points (2 points in this case),
+    and report their indices in the original dataset.
+    """
+
+    if percentage <= 0.0 or percentage > 100.0:
+        raise ValueError("Percentage must be greater than 0 and lower than or equal to 100")
+
+    if not isinstance(seed, int):
+        raise ValueError("The input seed must be an integer number")
+
+    unique_labels = list(set(labels))
+
+    if len(unique_labels) < 2:
+        raise ValueError("The list of class labels must contain at least two unique lables")
+
+    rand = np.random.default_rng(seed=seed)
+
+    selection = list()
+
+    for label in unique_labels:
+        # Get a specific percentage of the data points for a specific class
+        select_points = percentage * labels.count(label) / 100.0
+
+        # Retrieve the indices of the samples under a specific class in the original dataset
+        indices = [pos for pos, val in enumerate(labels) if val == label]
+
+        # Finally subsample the list of indices according to the specific percentage
+        selection.extend([indices[i] for i in rand.choice(len(indices), int(select_points), replace=False)])
+
+    return sorted(selection)
+
+
+def chopin2():
+    """Domain-agnostic supervised learning with hyperdimensional computing.
+    
+    Notes
+    -----
+    chopin2 is available in GitHub at https://github.com/cumbof/chopin2 and its ML model is described
+    in the following scientific article:
+
+    Cumbo F, Cappelli E, Weitschek E.
+    A brain-inspired hyperdimensional computing approach for classifying massive dna methylation data of cancer
+    Algorithms. 2020 Sep 17;13(9):233
+    https://doi.org/10.3390/a13090233
+    """
+
+    # Load command line parameters
+    args = read_params()
+
+    if args.feature_selection and args.kfolds == 0:
+        raise Exception("The --feature-selection option can only be used in conjunction with --kfolds")
+
+    if args.kfolds == 0 and args.test_percentage == 0.0:
+        raise Exception(
+            (
+                "Please use --kfolds if you want to cross-validate your model. "
+                "Otherwise, use --test-percentage to specify the percentage of data points for the test set. "
+                "Use --help for other options"
+            )
+        )
+
+    if args.nproc < 1:
+        args.nproc = os.cpu_count()
+
+    # Load the input matrix
+    print("Loading dataset")
+    
+    _, features, content, classes = load_dataset(args.input, sep=args.fieldsep)
+
+    class_labels = sorted(list(set(classes)))
+
+    print("Points: {}; Features {}; Classes {}".format(len(content), len(features), len(class_labels)))
+
+    # Initialise the model
+    print("Building the HD model")
+    
+    model = ClassificationModel(size=args.dimensionality, levels=args.levels, vtype="bipolar")
+
+    if args.feature_selection:
+        print("Selecting features.. This may take a while\n")
+
+        # Run the feature selection
+        importances, scores, best_importance, count_models = model.stepwise_regression(
+            content,
+            features,
+            classes,
+            method=args.feature_selection,
+            cv=args.kfolds,
+            distance_method="cosine",
+            retrain=args.retrain,
+            n_jobs=args.nproc,
+            metric="accuracy",
+            threshold=args.threshold,
+            uncertainty=args.uncertainty
+        )
+
+        # Print features in ascending order on their score
+        table = [["Feature", "Importance"]]
+
+        for feature in sorted(importances.keys(), key=lambda f: importances[f]):
+            table.append([feature, importances[feature]])
+
+        print(tabulate(table, headers="firstrow", tablefmt="simple"))
+
+        print()
+
+        # Also print the score for each importance level
+        table = [["Importance", "Score (accuracy)"]]
+
+        for imp in sorted(scores.keys()):
+            table.append([imp, "{:.4f}".format(scores[imp])])
+
+        print(tabulate(table, headers="firstrow", tablefmt="simple"))
+
+        print("\nBest importance: {}".format(best_importance))
+
+        # Select features based on the best importance
+        if args.feature_selection == "backward":
+            selected_features = [feature for feature in importances if importances[feature] <= best_importance]
+
+        elif args.feature_selection == "forward":
+            selected_features = [feature for feature in importances if importances[feature] >= best_importance]
+
+        print("Selected features: {}\n".format(len(selected_features)))
+
+        # Also print the score for each importance level
+        table = [["Features"]]
+
+        for feature in selected_features:
+            table.append([feature])
+
+        print(tabulate(table, headers="firstrow", tablefmt="simple"))
+
+        print("\nTotal ML models: {}".format(count_models))
+
+        # Replace features with their positions in the original list of features
+        selected_features = [features.index(feature) for feature in selected_features]
+
+        print("\nBuilding a model with the selected features only")
+
+        # Reshape content by considering the selected features only
+        content = [[value for position, value in enumerate(sample) if position in selected_features] for sample in content]
+
+    # Fit the model
+    model.fit(content, classes)
+
+    if args.kfolds > 0:
+        # Predict in cross-validation
+        print("Cross-validating model with {} folds\n".format(args.kfolds))
+
+        predictions = model.cross_val_predict(
+            content,
+            classes,
+            cv=args.kfolds,
+            distance_method="cosine",
+            retrain=args.retrain,
+            n_jobs=args.nproc
+        )
+
+    elif args.test_percentage > 0.0:
+        # Predict with a percentage-split
+        print("Percentage-split: training={}% test={}%\n".format(100.0 - args.test_percentage, args.test_percentage))
+
+        test_indices = percentage_split(classes, args.test_percentage)
+
+        predictions = [
+            model.predict(
+                test_indices,
+                distance_method="cosine",
+                retrain=args.retrain
+            )
+        ]
+
+    # For each prediction, compute the Accuracy, F1, Precision, Recall, AUC
+    accuracy_scores = list()
+    f1_scores = list()
+    precision_scores = list()
+    recall_scores = list()
+    mcc_scores = list()
+
+    retraining_iterations = list()
+    error_rates = list()
+
+    print("Class labels: {}\n".format(class_labels))
+
+    for fold, (y_indices, y_pred, _, retrainings, error_rate, _) in enumerate(predictions):
+        # Produce the confusion matrix for each fold
+        print("Fold {} ({} retrainings)".format(fold + 1, retrainings))
+        retraining_iterations.append(retrainings)
+
+        print("\tError rate: {}".format(error_rate))
+        error_rates.append(error_rate)
+
+        y_true = [classes[position] for position in y_indices]
+
+        fold_accuracy = accuracy_score(y_true, y_pred)
+        print("\tAccuracy: {}".format("{:.4f}".format(fold_accuracy)))
+        accuracy_scores.append(fold_accuracy)
+
+        fold_f1 = f1_score(y_true, y_pred, average="weighted")
+        print("\tF1: {}".format("{:.4f}".format(fold_f1)))
+        f1_scores.append(fold_f1)
+
+        fold_precision = precision_score(y_true, y_pred, average="weighted")
+        print("\tPrecision: {}".format("{:.4f}".format(fold_precision)))
+        precision_scores.append(fold_precision)
+
+        fold_recall = recall_score(y_true, y_pred, average="weighted")
+        print("\tRecall: {}".format("{:.4f}".format(fold_recall)))
+        recall_scores.append(fold_recall)
+
+        fold_mcc = matthews_corrcoef(y_true, y_pred)
+        print("\tMatthews Corr. Coeff.: {}".format("{:.4f}".format(fold_mcc)))
+        mcc_scores.append(fold_mcc)
+
+        print("\tConfusion Matrix:")
+        if len(class_labels) > 2:
+            for row in confusion_matrix(y_true, y_pred, labels=class_labels):
+                print("\t\t{}".format(row))
+
+        else:
+            tn, fp, fn, tp = confusion_matrix(y_true, y_pred, labels=class_labels).ravel()
+
+            print("\t\tTN: {}".format(tn))
+            print("\t\tFP: {}".format(fp))
+            print("\t\tFN: {}".format(fn))
+            print("\t\tTP: {}".format(tp))
+
+        print()
+
+    for score_label, score_values in zip(
+        ["Retrainings", "Error Rate", "Accuracy", "F1", "Precision", "Recall", "Matthews Corr. Coeff."],
+        [retraining_iterations, error_rates, accuracy_scores, f1_scores, precision_scores, recall_scores, mcc_scores]
+    ):
+        print(
+            "{}: {:.4f}{}".format(
+                score_label,
+                statistics.mean(score_values),
+                " ({:.4f} stdev)".format(statistics.stdev(score_values)) if len(score_values) > 1 else ""
+            )
+        )
+
+
+if __name__ == "__main__":
+    # Pre-parse --output only so redirection is set up before full argument parsing
+    _pre = ap.ArgumentParser(add_help=False)
+    _pre.add_argument("--output", default=None)
+    _output_arg, _ = _pre.parse_known_args()
+
+    t0 = time.time()
+
+    if _output_arg.output:
+        with open(_output_arg.output, "w") as _outfile, contextlib.redirect_stdout(_outfile):
+            chopin2()
+            t1 = time.time()
+            print("Total elapsed time: {}s".format(int(t1 - t0)))
+        print("Output written to: {}".format(_output_arg.output))
+    else:
+        chopin2()
+        t1 = time.time()
+        print("Total elapsed time: {}s".format(int(t1 - t0)))

hdlib-2.1.0.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: hdlib
+Version: 2.1.0
+Summary: Hyperdimensional Computing Library for building Vector Symbolic Architectures in Python
+Author-email: Fabio Cumbo <fabio.cumbo@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/cumbof/hdlib
+Project-URL: Issues, https://github.com/cumbof/hdlib/issues
+Project-URL: Source, https://github.com/cumbof/hdlib
+Project-URL: Wiki, https://github.com/cumbof/hdlib/wiki
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mthree>=3.0.0
+Requires-Dist: numpy>=2.3.4
+Requires-Dist: qiskit>=2.2.1
+Requires-Dist: qiskit-aer>=0.17.2
+Requires-Dist: qiskit-ibm-runtime>=0.42.0
+Requires-Dist: scikit-learn>=1.7.2
+Requires-Dist: scipy>=1.16.2
+Requires-Dist: tabulate>=0.9.0
+Provides-Extra: examples
+Requires-Dist: qiskit_machine_learning>=0.8.4; extra == "examples"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Provides-Extra: dev
+Requires-Dist: build>=1; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# hdlib
+
+Hyperdimensional Computing Library for building Vector-Symbolic Architectures in Python 3.
+
+![Conda](https://img.shields.io/conda/dn/conda-forge/hdlib?label=hdlib%20in%20Conda)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.05704/status.svg)](https://doi.org/10.21105/joss.05704)
+[![DOI](https://zenodo.org/badge/485488487.svg)](https://doi.org/10.5281/zenodo.7996502)
+
+Vector-Symbolic Architectures (VSA, a.k.a. Hyperdimensional Computing) is an emergent computing paradigm that works by combining vectors in a high-dimensional space for representing and processing information. This approach recently shown promise in various domains for dealing with different kind of computational problems, including artificial intelligence, cognitive science, robotics, natural language processing, bioinformatics, medical informatics, cheminformatics, and internet of things among other scientific disciplines.
+
+Here we present _hdlib_, a Python library for designing Vector-Symbolic Architectures. It is distributed under the MIT license as a Python package through PyPI and Conda on the _conda-forge_ channel.
+
+GitHub releases are also available on Zenodo at [https://doi.org/10.5281/zenodo.7996502](https://doi.org/10.5281/zenodo.7996502).
+
+Please refer to the official [Wiki](https://github.com/cumbof/hdlib/wiki) for any information about the implemented modules and how to use the library.
+
+Here is the table of content:
+
+- [Getting started](https://github.com/cumbof/hdlib/wiki/Getting-started)
+  - [Installing `hdlib`](https://github.com/cumbof/hdlib/wiki/Getting-started#installing-hdlib)
+  - [Dependencies](https://github.com/cumbof/hdlib/wiki/Getting-started#dependencies)
+- [Vector-Symbolic Architectures](https://github.com/cumbof/hdlib/wiki/Vector-Symbolic-Architectures)
+  - [Hyperdimensional Vectors and Space](https://github.com/cumbof/hdlib/wiki/Vector-Symbolic-Architectures#hyperdimensional-vectors-and-space)
+  - [Arithmetic operations](https://github.com/cumbof/hdlib/wiki/Vector-Symbolic-Architectures#arithmetic-operations)
+- [Examples](https://github.com/cumbof/hdlib/wiki/Examples)
+  - [What is the Dollar of Mexico?](https://github.com/cumbof/hdlib/wiki/Examples#what-is-the-dollar-of-mexico)
+  - [Classification Model](https://github.com/cumbof/hdlib/wiki/Examples#classification-model)
+  - [Stepwise Feature Selection](https://github.com/cumbof/hdlib/wiki/Examples#stepwise-feature-selection)
+  - [Graph Encoding](https://github.com/cumbof/hdlib/wiki/Examples#graph-encoding)
+  - [Regression Model](https://github.com/cumbof/hdlib/wiki/Examples#regression-model)
+  - [Clustering](https://github.com/cumbof/hdlib/wiki/Examples#clustering)
+- [Support and contributions](https://github.com/cumbof/hdlib/wiki/Support-and-contributions)
+
+## Agent Skills
+
+Want to use `hdlib` with an LLM coding assistant? The [**hdlib-skills**](https://github.com/cumbof/hdlib-skills) repository provides a collection of [Agent Skills](https://github.com/cumbof/hdlib-skills) that teach LLM agents how to use the library effectively.
+
+The skills cover foundational concepts (vectors, space, arithmetic, and distance operations), machine learning models (classification, clustering, regression, graph encoding, and feature selection), quantum hyperdimensional computing, and common usage patterns (analogical reasoning, data encoding, and troubleshooting).
+
+They are compatible with any tool that supports the Agent Skills standard. See the [hdlib-skills](https://github.com/cumbof/hdlib-skills) repository for installation and usage instructions.
+
+## Credits
+
+Please credit our work in your manuscript by citing:
+
+```bibtex
+@article{cumbo2023hdlib,
+  title   = {hdlib: A python library for designing Vector-Symbolic Architectures},
+  author  = {Cumbo, Fabio and Weitschek, Emanuel and Blankenberg, Daniel},
+  journal = {Journal of Open Source Software},
+  volume  = {8},
+  number  = {89},
+  pages   = {5704},
+  year    = {2023},
+  doi     = {10.21105/joss.05704}
+}
+
+@misc{cumbo2026hdlib,
+  title         = {hdlib 2.0: Extending Machine Learning Capabilities of Vector-Symbolic Architectures}, 
+  author        = {Fabio Cumbo and Kabir Dhillon and Daniel Blankenberg},
+  year          = {2026},
+  eprint        = {2601.02509},
+  archivePrefix = {arXiv},
+  primaryClass  = {cs.LG},
+  url           = {https://arxiv.org/abs/2601.02509}
+}
+```
+
+## Other publications
+
+`hdlib` has been cited in the following selected publications. If you have used our library in your research, we would love to hear from you!
+
+> Cumbo et al., (2020). A brain-inspired hyperdimensional computing approach for classifying massive DNA methylation data of cancer. _Algorithms_, 13(9), 233. https://doi.org/10.3390/a13090233
+> 
+> Cumbo et al., (2025). Feature selection with vector-symbolic architectures: a case study on microbial profiles of shotgun metagenomic samples of colorectal cancer. _Briefings in Bioinformatics_, 26(2), bbaf177. https://doi.org/10.1093/bib/bbaf177
+>
+> Joshi et al., (2025). Large-scale classification of metagenomic samples: a comparative analysis of classical machine learning techniques vs a novel brain-inspired hyperdimensional computing approach. _bioRxiv_, 2025-07. https://doi.org/10.1101/2025.07.06.663394
+>
+> Cumbo et al., (2025). Hyperdimensional computing in biomedical sciences: a brief review. _PeerJ Computer Science_, 11, e2885. https://doi.org/10.7717/peerj-cs.2885
+>
+> Cumbo et al., (2026). A novel Vector-Symbolic Architecture for graph encoding and its application to viral pangenome-based species classification. _BioData Mining_, 2026-05. https://doi.org/10.1186/s13040-026-00561-1
+>
+> Cumbo et al., (2026). Quantum Hyperdimensional Computing: a foundational paradigm for quantum neuromorphic architectures. _npj Unconventional Computing_, 3(1), 21. https://doi.org/10.1038/s44335-026-00064-6
+>
+> Cumbo et al., (2026). Designing vector-symbolic architectures for biomedical applications: ten tips and common pitfalls. _PeerJ Computer Science_, 12, e3682. https://doi.org/10.7717/peerj-cs.3682
+>
+> Cumbo et al., (2026). Predicting the toxicity of chemical compounds via Hyperdimensional Computing. _Molecular Informatics_, 45(9), e70052. https://doi.org/10.1002/minf.70052
+
+## Support and contributions
+
+Long-term discussion and bug reports are maintained via [GitHub Issues](https://github.com/cumbof/hdlib/issues), while code review is managed via [GitHub Pull Requests](https://github.com/cumbof/hdlib/pulls).
+
+Please, (i) be sure that there are no existing issues/PR concerning the same bug or improvement before opening a new issue/PR; (ii) write a clear and concise description of what the bug/PR is about; (iii) specifying the list of steps to reproduce the behavior in addition to versions and other technical details is highly recommended.
+
+For additional information about how to contribute, please visit the [CONTRIBUTING](https://github.com/cumbof/hdlib/blob/main/CONTRIBUTING.md) section.
+
+Copyright © 2025 [Fabio Cumbo](https://github.com/cumbof). See [LICENSE](https://github.com/cumbof/hdlib/blob/main/LICENSE) for additional details.

hdlib-2.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+hdlib/__init__.py,sha256=g9mnTtKKnjq9rCSPMUxNMMZiGPlGnsHnU85XjvlIYJg,971
+hdlib/space.py,sha256=n_lugViNaEEba4_YxwiKvCE08dBwkYi9hRgjY6TQRsY,27851
+hdlib/vector.py,sha256=FVM-u3ZsVshnYxntwHBbeGjzD3-Jkfqu0TYWHRrQKV8,19522
+hdlib/arithmetic/__init__.py,sha256=8hsuBDcZaTOu3DlOxkq_YEczItPOw1pWYVFWYbcWvKU,8631
+hdlib/arithmetic/quantum.py,sha256=hOI1CTDTUpzYlm-k7ClSmJQPY_8P89sf1nPoVTtrpPE,47178
+hdlib/model/__init__.py,sha256=IgKxeCkbsafRHxyAc9VBBMwc0mknIeKHEC-9nMgrEzs,480
+hdlib/model/classification.py,sha256=MZmCcd30EOsGVDnTA_yJm7EzM2f-FtEVxOkni2znzL8,65676
+hdlib/model/clustering.py,sha256=SRrszF-4jehb-qM4wUh5CZt1VdVGUVRyF-1BTOEZ_x8,6054
+hdlib/model/graph.py,sha256=SQm-3tHlZV6kVHJU2F5CLGd_EZqr5MA-lYKSWDTHy-w,29029
+hdlib/model/regression.py,sha256=ZuPMc2aNaQnt2htTCwN06hgDERysN5_JsvElLHISFWo,12187
+hdlib-2.1.0.data/scripts/chopin2.py,sha256=fQfqZFdoiv3mutM3PMrsKSPu9HsaPO5ZUg8tpZE-tZ0,15163
+hdlib-2.1.0.dist-info/licenses/LICENSE,sha256=xkysxBzIkuF29D7Bx4jMZ0gHs9lXByEH68cGA-Q9SyA,1068
+hdlib-2.1.0.dist-info/METADATA,sha256=YeWGbICKb2F-HY6wiBAAeY5yiSRJxL3nikXrdCTB3dk,8627
+hdlib-2.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hdlib-2.1.0.dist-info/top_level.txt,sha256=v-fN9sWXMqxwB1KBgCMT7oEj3MLsuiQMgV6BI6VIZ3c,6
+hdlib-2.1.0.dist-info/RECORD,,

hdlib-2.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hdlib-2.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Fabio Cumbo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hdlib-2.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hdlib