https://github.com/expander/polylog.rs

Rust implementation of polylogarithms.
https://github.com/expander/polylog.rs

math polylogarithm rust special-functions

Last synced: 3 days ago
JSON representation

Rust implementation of polylogarithms.

• Host: GitHub
• URL: https://github.com/expander/polylog.rs
• Owner: Expander
• Created: 2018-09-25T12:19:40.000Z (about 6 years ago)
• Default Branch: master
• Last Pushed: 2024-03-06T17:00:39.000Z (8 months ago)
• Last Synced: 2024-10-28T17:33:08.294Z (18 days ago)
• Topics: math, polylogarithm, rust, special-functions
• Language: Rust
• Homepage:
• Size: 7.04 MB
• Stars: 1
• Watchers: 3
• Forks: 0
• Open Issues: 1
• Metadata Files:
  • Readme: README.md
  • Citation: CITATION.cff

Awesome Lists containing this project

README

        
polylog

=======

[![Build Status](https://github.com/Expander/polylog/workflows/test/badge.svg)](https://github.com/Expander/polylog/actions)

[![Documentation](https://docs.rs/polylog/badge.svg)](https://docs.rs/polylog/)

[![Coverage Status](https://coveralls.io/repos/github/Expander/polylog.rs/badge.svg)](https://coveralls.io/github/Expander/polylog.rs)

The polylog package provides Rust implementations of real and complex

polylogarithms, including the dilogarithm and trilogarithm.

The polylog package depends on the `num` crate.

Example

-------

```rust

use num::complex::Complex;

use polylog::{Li, Li0, Li1, Li2, Li3, Li4, Li5, Li6};

let x = 1.0;

let z = Complex::new(1.0, 1.0);

let n = 10;

// real polylogarithms for real arguments

println!("Li0({}) = {}", x, x.li0());      // Re[Li_0(x)]

println!("Li1({}) = {}", x, x.li1());      // Re[Li_1(x)]

println!("Li2({}) = {}", x, x.li2());      // Re[Li_2(x)] (dilogarithm)

println!("Li3({}) = {}", x, x.li3());      // Re[Li_3(x)] (trilogarithm)

println!("Li4({}) = {}", x, x.li4());      // Re[Li_4(x)]

println!("Li_{}({}) = {}", n, x, x.li(n)); // Re[Li_n(x)]

// complex polylogarithms for complex arguments

println!("Li0({}) = {}", z, z.li0());      // Li_0(z)

println!("Li1({}) = {}", z, z.li1());      // Li_1(z)

println!("Li2({}) = {}", z, z.li2());      // Li_2(z) (dilogarithm)

println!("Li3({}) = {}", z, z.li3());      // Li_3(z) (trilogarithm)

println!("Li4({}) = {}", z, z.li4());      // Li_4(z)

println!("Li5({}) = {}", z, z.li5());      // Li_5(z)

println!("Li6({}) = {}", z, z.li6());      // Li_6(z)

println!("Li_{}({}) = {}", n, z, z.li(n)); // Li_n(z)

```

Notes

-----

The implementation of the real dilogarithm is an adaptation of

[[arXiv:2201.01678](https://arxiv.org/abs/2201.01678)].

The implementation of the complex dilogarithm has been inspired by the

implementation in [SPheno](https://spheno.hepforge.org) and has been

translated to Rust.

The implementation of the real trilogarithm is an adaptation of

[[arXiv:2308.11619](https://arxiv.org/abs/2308.11619)].

The implementation of the general n-th order polylogarithm is an

adaptation of [[arXiv:2010.09860](https://arxiv.org/abs/2010.09860)].

Copying

-------

polylog is licenced under the GNU Lesser General Public License (GNU

LGPL) version 3.