polylog/lib.rs
1//! Polylog
2//! =======
3//!
4//! The Polylog package provides Rust implementations of real and
5//! complex polylogarithms, including the dilogarithm and
6//! trilogarithm.
7//!
8//! # Example:
9//! ```
10//! use num::complex::Complex;
11//! use polylog::{Li, Li0, Li1, Li2, Li3, Li4, Li5, Li6};
12//!
13//! let x = 1.0;
14//! let z = Complex::new(1.0, 1.0);
15//! let n = 10;
16//!
17//! // real polylogarithms for real arguments
18//! println!("Li0({}) = {}", x, x.li0()); // Re[Li_0(x)]
19//! println!("Li1({}) = {}", x, x.li1()); // Re[Li_1(x)]
20//! println!("Li2({}) = {}", x, x.li2()); // Re[Li_2(x)] (dilogarithm)
21//! println!("Li3({}) = {}", x, x.li3()); // Re[Li_3(x)] (trilogarithm)
22//! println!("Li4({}) = {}", x, x.li4()); // Re[Li_4(x)]
23//! println!("Li_{}({}) = {}", n, x, x.li(n)); // Re[Li_n(x)]
24//!
25//! // complex polylogarithms for complex arguments
26//! println!("Li0({}) = {}", z, z.li0()); // Li_0(z)
27//! println!("Li1({}) = {}", z, z.li1()); // Li_1(z)
28//! println!("Li2({}) = {}", z, z.li2()); // Li_2(z) (dilogarithm)
29//! println!("Li3({}) = {}", z, z.li3()); // Li_3(z) (trilogarithm)
30//! println!("Li4({}) = {}", z, z.li4()); // Li_4(z)
31//! println!("Li5({}) = {}", z, z.li5()); // Li_5(z)
32//! println!("Li6({}) = {}", z, z.li6()); // Li_6(z)
33//! println!("Li_{}({}) = {}", n, z, z.li(n)); // Li_n(z)
34//! ```
35
36
37mod cln;
38mod li0;
39mod li1;
40mod li2;
41mod li3;
42mod li4;
43mod li5;
44mod li6;
45mod li;
46
47pub use self::li0::Li0;
48pub use self::li1::Li1;
49pub use self::li2::Li2;
50pub use self::li3::Li3;
51pub use self::li4::Li4;
52pub use self::li5::Li5;
53pub use self::li6::Li6;
54pub use self::li::Li;