Skip to main content

Fermi-Dirac Integrals (FDINT)

FDINT is a free, open-source python package that provides fast, double precision (64-bit floating point) approximations to the Fermi-Dirac integrals of integer and half integer order, based on the work by Prof. Fukushima [1].

The source code and documentation (coming soon) are graciously hosted by GitHub.

Installation

In order to use FDINT, you must having a working Python distribution installed. Python 3 support has not yet been tested, so Python 2.7 is suggested. In order to achieve the highest performance, a Fortran 90 compiler, such as gfortran, is required.

From PyPi

This is the easiest method. Install from PyPi by running the following command:

pip install fdint

From Github

First, you will need to install the following prerequisite package:

- Numpy_

Additional functionality is provided by the following optional packages:

- Matplotlib_

Once these are installed, download the latest release .zip or .tar.gz source package from the github page, extract its contents, and run python setup.py install from within the extracted directory.

Testing

Once installed, you can test the package by running the following command:

python -m fdint.tests

If you have Matplotlib installed, you can also plot a sample of the available functions by running the following command:

python -m fdint

Tutorial

First, start up an interactive python shell from the command line:

$ python

Next, import everything from the fdint package:

>>> from fdint import *

Now you can access the Fermi-Dirac integral and derivative convenience functions, fdk and dfdk:

>>> fdk(k=0.5,phi=-10)
4.0233994366893939e-05
>>> fdk(0.5,-10)
4.0233994366893939e-05
>>> fdk(k=0.5,phi=5)
7.837976057293096
>>> fdk(k=0.5,phi=50)
235.81861512588432
>>> dfdk(k=0.5,phi=-10,d=1) # first derivative
4.0233348580568672e-05
>>> dfdk(k=0.5,phi=5,d=1)
2.1916282173557855
>>> dfdk(k=0.5,phi=50,d=1)
7.0699026455055112
>>> dfdk(k=0.5,phi=50,d=2) # second derivative
0.07074571454521902

You can also pass in lists or arrays as phi:

>>> fdk(k=0.5,phi=[-10,0,10])
array([  4.02339944e-05,   6.78093895e-01,   2.13444715e+01])

If you request an order or derivative that is not implemented, a NotImplementedError is raised:

>>> fdk(22,0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "fdint/fdint.py", line 68, in fdk
    raise NotImplementedError()
NotImplementedError
>>> dfdk(k=0.5,phi=50,d=10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "fdint/fdint.py", line 99, in dfdk
    raise NotImplementedError()
NotImplementedError

If you prefer to call the low-level functions directly to avoid overhead, you can access them from the fd module:

>>> fd.fd1h(-10) # k=1/2
4.023399436689394e-05
>>> fd.vfd1h([-10,0,10]) # k=1/2
array([  4.02339944e-05,   6.78093895e-01,   2.13444715e+01])

Benchmarks

For single values, calling the function for a specific order is ~7x faster than calling fdk:

$ python -m timeit -s "from fdint import fdk" "fdk(0.5, 10)"
1000000 loops, best of 3: 1.1 usec per loop
$ python -m timeit -s "from fdint.fd import fd1h" "fd1h(10)"
10000000 loops, best of 3: 0.153 usec per loop

However, even for a fairly small array of 1000, most of the advantage is lost:

$ python -m timeit -s "from fdint import fdk; import numpy; x=numpy.linspace(-100,100,1000)" "fdk(0.5, x)"
100000 loops, best of 3: 13.8 usec per loop
$ python -m timeit -s "from fdint.fd import vfd1h; import numpy; x=numpy.linspace(-100,100,1000)" "vfd1h(x)"
100000 loops, best of 3: 12.9 usec per loop

Overall, the performance is excellent. Note that the call time is within a factor of 2 of numpy.exp.

$ python -m timeit -s “import numpy; from numpy import exp; x=numpy.linspace(-100,100,1000)” “exp(x)” 100000 loops, best of 3: 7.49 usec per loop

Documentation

The documentation (coming soon) is graciously hosted by GitHub.

Metadata

Release files for fdint 1.1

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for fdint 1.1
File Size Uploaded Provenance Actions
fdint-1.1.tar.gz 51.5 kB Without provenance Details for fdint-1.1.tar.gz

Release files / fdint-1.1.tar.gz

Download URL fdint-1.1.tar.gz
Size 51.5 kB
Tags Source
SHA-256 checksum
How to use checksums
98cd913fa9c2a24799092db13d8fdd365197518c79812d3a3bd01bf8b4be1606
BLAKE2b-256 checksum
How to use checksums
31ff593e0c17edf6a2afec0c77deb25cb26524c1f073e4feda46249aebd6ef66
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No

Security for fdint 1.1

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page