semvec/pypi-packages huggingface dataset:
decimalfp 0.13.0
Decimal numbers with fixed-point arithmetic
Requires Python: >=3.11

The module _decimalfp_ provides a _Decimal_ number type which can represent
decimal numbers of (nearly) arbitrary magnitude and very large precision, i.e. 
with a very large number of fractional digits.

### Usage

_decimalfp.Decimal_ instances are created by giving a _value_ (default: 0) and
a _precision_ (i.e the number of fractional digits, default: None).

If _precision_ is given, it must be of type _int_ and >= 0.

If _value_ is given, it must either be a string, an instance of 
_number.Integral_, _number.Rational_ (for example _fractions.Fraction_), 
_decimal.Decimal_ or _float_ or be convertable to a _float_ or an _int_.

If a string is given as value, it must be a string in one of two formats:

    [+|-]<int>[.<frac>][<e|E>[+|-]<exp>] or
    [+|-].<frac>[<e|E>[+|-]<exp>].

The value is always adjusted to the given precision or the precision is
calculated from the given value, if no precision is given.

When the given _precision_ is lower than the precision of the given _value_,
the result is rounded, according to the current default rounding mode (which 
itself defaults to ROUND_HALF_EVEN).

When no _precision_ is given and the given _value_ is a _float_ or a
_numbers.Rational_ (but no _Decimal_), the _Decimal_ constructor tries to
convert _value_ exactly. But this is done only up a fixed limit of fractional 
digits (imposed by the implementation, currently 65535). If _value_ can not be 
represented as a _Decimal_ within this limit, an exception is raised.

_Decimal_ does not deal with infinity, division by 0 always raises a
_ZeroDivisionError_. Likewise, infinite instances of type _float_ or
_decimal.Decimal_ can not be converted to _Decimal_ instances. The same is
true for the 'not a number' instances of these types.

### Computations

When importing _decimalfp_, its _Decimal_ type is registered in Pythons
numerical stack as subclass of _number.Rational_. It supports all operations 
defined for that base class and its instances can be mixed in computations 
with instances of all numeric types mentioned above.

All numerical operations give an exact result, i.e. they are not automatically
constraint to the precision of the operands or to a number of significant
digits (like the floating-point _Decimal_ type from the standard module
_decimal_). When the result can not exactly be represented by a _Decimal_
instance within the limit of fractional digits, an instance of
_fractions.Fraction_ is returned.

_Decimal_ supports rounding via the built-in function _round_ using the same
rounding mode as the _float_ type by default (ROUND_HALF_EVEN in Python 3). In 
addition, via the method _adjusted_, a _Decimal_ with a different precision 
can be derived, supporting all rounding modes defined by the standard library 
module _decimal_.

For more details see the documentation provided with the source distribution
or [here](https://decimalfp.readthedocs.io/en/latest).
qcodespp 0.1.15
Package providing additional functions for QCoDeS
Requires Python: >=3.10

qcodes++
===================================

qcodes++ (aka qcodespp, qcpp, qc++) is a python package to run scientific experiments. qcodes++ is built on top of `QCoDeS <https://qcodes.github.io/Qcodes/>`__, both extending capabilities and preserving older features. QCoDeS contains a huge range of drivers for communicating with instruments,
and a flexible - but complex - database-based method for collecting data
and running experiments.

The qcodes++ package provides a user-friendly
frontend to the solid backend of QCoDeS. If you have always wanted to run 
your measurements using python but found QCoDeS too daunting, qcodes++ is 
the package for you. qcodes++ features:

* Simple yet powerful methods for running experiments and collecting data
* True live plotting featuring sub-second, point-by-point updates without performance impact
* A feature-rich offline plotting/analysis tool for publication-quality figures, including curve fitting, making linecuts of 2D data, smoothing, taking derivatives and more
* Text-based data storage for easy access and long-term stability
* Improvements to core QCoDeS functionalities (e.g. Station, Parameters) to streamline data acquisition, protect (meta)data integrity and minimise user error
* Improved drivers for certain instruments
* and other user-friendliness improvements

`qcodes++ is installed alongside/around QCoDeS <https://qcodespp.github.io/differences_from_qcodes.html>`__, meaning all features of both packages can be used 
seamlessly within the same notebook/environment. e.g. you could still use the QCoDeS 
dataset and measurement process for some experiments while relying on qcodes++ in other instances.
In addition, all top level qcodes functions are available in qcodes++ with the same names.

The name: In addition to being a really stupid pun on q(c++), it reflects the fact that really we just want 
to add some nice features to the main package, and also it makes me happy because totally 
coincidentally we have always named our plotting windows pp, e.g. pp = qc.live_plot().

Documentation
=============
is available at https://qcodespp.github.io

Installation
============

See https://qcodespp.github.io/installation.html

QCoDeS and qcodes++ are compatible with Python 3.10+. They are primarily intended for use
from Jupyter notebooks and Jupyter lab, but can also be used from Spyder, traditional terminal-based
shells and in stand-alone scripts.

License
=======

See `License <https://github.com/QCoDeS/Qcodes/tree/master/LICENSE.rst>`__.

Contact and contributing
==================================================

Issue reporting, feedback and contributions are more than welcome! The best way to raise an issue is through the GitHub issue tracker, and the best way to contribute is by forking the repository and submitting a pull request (see the relevant GitHub documentation for how to do this). This package is largely maintained by Damon Carrad. If you have a question but not a GitHub account, you can contact me at damonc@dtu.dk.
miblab-dl 0.0.10
Python API for miblab's trained deep-learning models
Keywords: python, medical imaging, MRI, deep learning

# miblab-dl

Python API for miblab's trained deep-learning models

## Installation in a working environment

If you are working in an existing environment with pytorch already installed, 
then all you need is this:

```bash
pip install miblab-dl
```

## Installation from scratch

If you start from scratch, first create a virtual environment, activate it 
and make sure you have the latest pip version. 

On Windows:

```bash
python -m venv myenv
myenv/Scripts/activate
python -m pip install --upgrade pip
```

On Mac or Linux:

```bash
python -m venv myenv
source myenv/bin/activate
python -m pip install --upgrade pip
```

Now install pytorch in your environment:

```bash
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
```

Then install the `miblab-dl` package:

```bash
pip install miblab-dl
```

## Usage

You can import `miblab-dl` functionality in a python script like this:

```python
import miblab_dl as dl
```

Then to compute fat and water maps from numpy arrays representing 
`in_phase` and `opposed_phase` Dixon images:

```python
fat, water = dl.fatwater(opposed_phase, in_phase)
```