semvec/pypi-packages huggingface dataset:
sigmond-scripts 1.0.2
Supporting functions for handling the c++ library sigmond
Requires Python: >=3.6

# Sigmond Scripts #

This repository contains a set of scripts used for the analysis of 2-point temporal correlation functions.
They depend on the sigmond analysis package ([https://bitbucket.org/ahanlon/sigmond](https://bitbucket.org/ahanlon/sigmond)),
and you should first have sigmond installed before using these scripts.

These functions are modified for the PyCALQ package.

### Directory structure ###

- analysis - contains the main scripts for running the analysis
    - run_sigmond.py - the driving script (pass -h to see options)
- data_conversion - contains various scripts for converting data to various formats (e.g. hdf5, LapH-binary, sigmond-bins).
- example_yamls - contains some example yaml files that can be passed to run_sigmond.py
- doc - contains documenation for how to use the analysis scripts (not up to date at all)

### What software requirements are there? ###

- Python 3.8 is required
- Many Python modules
    - wheel
    - cython
    - pybind11
    - pyyaml
    - progressbar
    - sortedcontainers
    - pylatex
    - numpy
    - uncertainties
    - aenum
    - tqdm
    - h5py
    - matplotlib

### How do I get started? ###

- You first need data in a format that sigmond can read (either LapH-binary or sigmond-bins).
  The data_conversion scripts can be used for this
torch-sparse-tensor 0.2.0
A sparse tensor framework for Pytorch.
Requires Python: <4.0,>=3.10

# PyTorch Sparse Tensors

A small package that implements the basic sparse tensor of any dimension.

## Key features

* Torch-like API for sparse tensor of n-dimension
* Support basic element-wise operations
* Support reduction (mean and sum) over 1 or multiple dimensions
* Support reshaping and broadcasting
* Support concatenation over 1 or multiple dimensions

## Installation

```bash
pip install torch-sparse-tensor
```

## Demo

Import package
```python
import torch
from sparse import SparseTensor
```

Build sparse tensors
```python
a = SparseTensor(
    torch.tensor([[0, 3, 1, 1, 2, 2, 3], [0, 0, 1, 2, 1, 2, 3]], dtype=torch.long),
    torch.tensor([[1], [5], [1], [1], [1], [1], [1]], dtype=torch.float32),
    shape=(4, 4),
)
b = SparseTensor(
    torch.tensor([[0, 1, 1, 2, 3], [0, 1, 2, 2, 3]], dtype=torch.long),
    torch.tensor([[1], [2], [1], [1], [1]], dtype=torch.float32),
    shape=(4, 4),
)
```

To cuda device
```python
a = a.to("cuda")
b = b.to("cuda")
```

Conversion to dense representation
```python
print(a.to_dense())
print(b.to_dense())
```

Basic element-wise operations
```python
c=a+b
print(c.to_dense())

d=a*b
print(d.to_dense())
```

Reduction operations
```python
print(a.sum(0).to_dense())
print(a.mean(0).to_dense())
```

Indexing and broadcasting
```python
print((a[:, None, :] + a[:, :, None]).sum(0).to_dense())
```

Concatenation over several dimensions
```python
print(SparseTensor.cat((a, b), dim=1).to_dense())
print(SparseTensor.cat((a, b), dim=(0,1)).to_dense())
```
ChemInterface-ppchem 2.2
...
Requires Python: >=3.8
Keywords: Mass spectroscopy, unsaturation

# - ChemInterface package for applied mass spectrometry -
#### Project in practical programming in chemistry course
#### EPFL CH-200

This repository provides the user with a package which will display an interactive interface where the user will be able to input the SMILEs of a molecule. The interface will be able to give specific information about the molecule such as its molecular mass, its organic functional groups or its degree of insaturation. The most important part of the package will provide a way to simulate the mass spectrum of the given molecule. 

Developpers:
- Thomas Christianson, genius coder and CTO of SwissChemInfoTech, https://github.com/ThomasCsson
- Igor Gonteri, brilliant back-end developper and founder of AppliedOrbitals.Org, https://github.com/igorgonteri
- Arthur Humery, leading expert amongst the new generation of Computational Chemical Programmers and CEO of the United Kingdom of Great Britain and Northern Ireland, https://github.com/Arthurhmy

**What is mass spectrometry ?**
   - Mass spectrometry is an analytical technique used to identify and quantify chemical compounds in a sample by measuring the mass and sometimes the charge of molecules. It involves separating ions according to their mass-to-charge ratio (m/z), then detecting and analysing them. This method is widely used in chemistry, biochemistry, pharmacology and other fields to characterise substances and understand their structure and composition.

Let us go through the steps required to make this package.

#### Imported packages

In order to run the package correctly, the following packages need to be installed before running any pip-installed functions using the following command

```bash
pip install matplotlib
pip install bokeh
pip install rdkit
pip install numpy
pip install pandas
pip install plotly
```
Specifically, from these packages, the following subpackages are required:
```bash
from rdkit import Chem
from rdkit.Chem import Draw
import matplotlib.pyplot as plt
spacyex 0.0.2
An extension for spaCy, making pattern matching as flexible as using regular expressions.
Requires Python: >=3.7

# spaCyEx

![spacy ex logo](/images/spacyex-logo.png)

`spaCyEx` is a powerful extension for spaCy, designed to make pattern matching as flexible and easy as using regular expressions. It builds upon the existing capabilities of spaCy's `Matcher`, enhancing it with a more accessible syntax for defining complex patterns. `spaCyEx` allows for intuitive and detailed text pattern specifications, perfect for extracting detailed linguistic features from texts.

## Installation

You can install `spaCyEx` via pip:

```bash
pip install spacyex
```

## Features

- Create complex matching patterns using a simple syntax.
- Supports all dictionary properties that are used by spaCy's `Matcher`.
- Easy integration with existing spaCy pipelines.

## Usage

Here is a simple example to get started with `spaCyEx`:

```python
import spacyex as se
import spacy

nlp = spacy.load("en_core_web_sm")
text = "John Smith runs fast, but Jacob Smith walks slowly."
pattern = "(ent_type=person|op={2}) (lemma=in[run,walk]) (pos=ADV)"

results = se.search(pattern, text, nlp)
for match in results:
    print(match[0].text, "Start:", match[1], "End:", match[2])
```

This code will match sequences in the text based on the defined pattern, using named entities, lemmas, and parts of speech.

## Roadmap

- [ ] Support for all dictionary properties in patterns.
- [ ] Additional utilities and helper functions for more complex pattern scenarios.