semvec/pypi-packages huggingface dataset:
snifa 0.5.3
Simple Numerical Instantaneous Frequency Approximation (SNIFA)
License: MIT
Requires Python: >=3.6

# SNIFA

SNIFA is a tiny Python library for computing an instantaneous frequency approximation numerically using a very simple algorithm. This algorithm was originally created for the purpose of analysing the gyrotropic dynamics of vortex based nano-oscillators but it can be used for any kind of varying monocomponent-frequency signal (only the main frequency is captured by the algorithm).

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install snifa.

```bash
pip install snifa
```

This package is also available in this private GitLab instance and can be installed using the `--extra-index-url` parameter.

```bash
pip install snifa --extra-index-url https://gitlab.flavio.be/api/v4/projects/9/packages/pypi/simple
```

## Usage

```python
import snifa
import numpy as np

ti, tf, nb_pts = 0, 1, 400
fs = nb_pts/(tf-ti) # sampling frequency
t = np.linspace(ti, tf, nb_pts)

f = 20+((100*t)**1)/2 # my shirp :-)
x = np.sin(2*np.pi*f*t)
y = np.cos(2*np.pi*f*t)

x *= (1.0 + 0.5 * np.sin(2*np.pi*3.0*t))
y *= (1.0 + 0.5 * np.sin(2*np.pi*3.0*t))

# Uncomment if only x-component is available
# and comment the other line with filt_freq
# t_, f_ = snifa.filt_freq(t, x, w_filt=0)
t_, f_ = snifa.filt_freq(t, x, y, w_filt=0)

# w_filt is a multiplyer of the number of cycles over which to
# perform a moving avereage. The default value is w_filt=1
# (w_filt=0 means no filtering)

import pylab as pp
pp.plot(t_, f_)
pp.xlabel('Time (s)')
pp.ylabel('Frequency (Hz)')
pp.show()
```

## Contributing
Pull requests are welcome.

## License
[MIT](https://choosealicense.com/licenses/mit/)
dependable 0.1.0
Dependency injection system extracted from FastAPI
License: MIT
Requires Python: >=3.6.1,<4.0.0

<h1 align="center">
    <strong>dependable</strong>
</h1>
<p align="center">
    <a href="https://github.com/dmtrs/dependable" target="_blank">
        <img src="https://img.shields.io/github/last-commit/dmtrs/dependable" alt="Latest Commit">
    </a>
        <img src="https://img.shields.io/github/workflow/status/dmtrs/dependable/Test">
        <img src="https://img.shields.io/codecov/c/github/dmtrs/dependable">
    <br />
    <a href="https://pypi.org/project/dependable" target="_blank">
        <img src="https://img.shields.io/pypi/v/dependable" alt="Package version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/dependable">
    <img src="https://img.shields.io/github/license/dmtrs/dependable">
</p>

Dependency injection system extracted from `fastapi`

```python
import asyncio
from random import random

from dependable import dependant, Depends

@dependant
async def main(*, choice: int = Depends(random)) -> None:
    print(choice)

asyncio.run(main())
```

More on [examples](examples/tick.py)

## Installation

``` bash
poetry add dependable # pip install dependable
```

## Python 3.6

- Backport require of [async-exit-stack](https://pypi.org/project/async-exit-stack/) and [async_generator](https://pypi.org/project/async_generator/)
```bash
poetry add async-exit-stack async_generator # pip install async-exit-stack async_generator
```

## Development

```bash
docker build -t dependable .
```

```bash
docker run --rm -v $(pwd):/usr/src/app dependable scripts/dev
```

## References

- [tiangolo/fastapi#2967](https://github.com/tiangolo/fastapi/issues/2967)

## License

This project is licensed under the terms of the MIT license.
scmpy 0.1.2
Set Covering Machine is a binary classification algorithm
License: MIT
Keywords: SET,COVER,BINARY,CLASSIFICATION,MACHINE,LEARNING

# Set Covering Machine

The Set Covering Machine is a learning algorithm for binary classification. The classifier is a solution of the set cover problem minimizing the empirical risk.

This implementation follow the idea presented in the original paper: 
![Marchand, Mario & Shawe-Taylor, John & Brodley, E. & Danyluk, Andrea. (2003). The Set Covering Machine. Journal of Machine Learning Research. 3. 10.1162/jmlr.2003.3.4-5.723. ](https://www.jmlr.org/papers/volume3/marchand02a/marchand02a.pdf)

So the *sets* are *balls* generated from the training set and the set cover problem is solved using greedy algorithm (Chvátal, 1979), accordingly to the paper. Sets can be combined in conjunction or disjunction and this can be specified using the parameter *machine_type*.

## How to install

You can install the package using pip:

    pip install scmpy

## Example
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import make_circles
    from scmpy import SCM

    # make some artificial data
    X, y = make_circles(n_samples=200, noise=0.2, factor=0.5, random_state=666)

    # split data in train and test
    X_train, X_test, y_train, y_test = \
        train_test_split(X, y, test_size=.3, random_state=7)

    scm = SCM(machine_type="disjunction")

    # fit the model
    scm.fit(X_train, y_train)

    # now the model is fitted, we can predict values

    # print accuracy
    print(scm.score(X_test, y_test))