Gauss-Quad

https://docs.rs/gauss-quad/latest
Admin
Gauss-quad is a Rust library that provides various Gaussian quadrature rules for numerical...
Tokens:183,521
Snippets:555
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Rust Midpoint Rule Integration Example

Source: https://docs.rs/gauss-quad/latest/gauss_quad/midpoint/index

Demonstrates numerical integration using the midpoint rule in Rust. This example shows how to initialize the Midpoint integrator, integrate various functions (quadratic, sine, piecewise exponential), and assert the results against expected values within a given epsilon. It requires the 'gauss-quad' and 'approx' crates.

```rust
use gauss_quad::midpoint::{Midpoint, MidpointError};
use approx::assert_abs_diff_eq;

use core::f64::consts::PI;

let eps = 0.001;

let n = 30;
let quad = Midpoint::new(n)?;

// integrate some functions
let two_thirds = quad.integrate(-1.0, 1.0, |x| x * x);
assert_abs_diff_eq!(two_thirds, 0.66666, epsilon = eps);

let estimate_sin = quad.integrate(-PI, PI, |x| x.sin());
assert_abs_diff_eq!(estimate_sin, 0.0, epsilon = eps);

// some functions need more steps than others
let m = 100;
let better_quad = Midpoint::new(m)?;

let piecewise = better_quad.integrate(-5.0, 5.0, |x| 
    if x > 1.0 && x < 2.0 {
        (-x * x).exp()
    } else {
        0.0
    }
);

assert_abs_diff_eq!(0.135257, piecewise, epsilon = eps);

```

--------------------------------

### Example: Integrate cos(x) * e^(-x^2)

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/hermite/mod

Illustrates integrating the function cos(x) * e^(-x^2) over the domain (-∞, ∞) using the `GaussHermite` rule. The example initializes a rule with 20 nodes and verifies that the calculated integral approximates PI.sqrt() / E.powf(0.25).

```rust
# use gauss_quad::hermite::{GaussHermite, GaussHermiteError};
# use approx::assert_abs_diff_eq;
# use core::f64::consts::{E, PI};
// initialize a Gauss-Hermite rule with 20 nodes
let quad = GaussHermite::new(20)?;

// numerically integrate a function over (-∞, ∞) using the Gauss-Hermite rule
let integral = quad.integrate(|x| x.cos());

assert_abs_diff_eq!(integral, PI.sqrt() / E.powf(0.25), epsilon = 1e-14);
# Ok::<(), GaussHermiteError>(())
```

--------------------------------

### Example Usage of Gauss-Legendre Integration (Rust)

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/legendre/mod

Demonstrates a basic example of using the GaussLegendre rule to numerically integrate a polynomial function over the domain [-1.0, 1.0]. It uses `assert_abs_diff_eq` for floating-point comparisons.

```rust
use gauss_quad::legendre::GaussLegendre;
# use gauss_quad::legendre::GaussLegendreError;
use approx::assert_abs_diff_eq;

let quad = GaussLegendre::new(10)?;
let integral = quad.integrate(-1.0, 1.0,
    |x| 0.125 * (63.0 * x.powi(5) - 70.0 * x.powi(3) + 15.0 * x)
);
assert_abs_diff_eq!(integral, 0.0);
# Ok::<(), GaussLegendreError>(())
```

--------------------------------

### Large Scale Gauss-Legendre Integration Example (Rust)

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/legendre/mod

Illustrates the capability of GaussLegendre for integrating over large domains with a high-degree rule. This example integrates the sine function over [-3.0, 3.0] using a rule with 1,000,000 nodes.

```rust
# use gauss_quad::legendre::{GaussLegendre, GaussLegendreError};
# use approx::assert_abs_diff_eq;
let quad = GaussLegendre::new(1_000_000)?;

let integral = quad.integrate(-3.0, 3.0, |x| x.sin());

assert_abs_diff_eq!(integral, 0.0);
# Ok::<(), GaussLegendreError>(())
```

--------------------------------

### Midpoint Rule Integration Example

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/midpoint/mod

Demonstrates how to use the `Midpoint` struct to numerically integrate functions. It shows initialization with a specified number of cells and integration of various functions, asserting the accuracy of the results. Includes error handling for initialization.

```rust
use gauss_quad::midpoint::{Midpoint, MidpointError};
use approx::assert_abs_diff_eq;

use core::f64::consts::PI;

let eps = 0.001;

let n = 30;
let quad = Midpoint::new(n)?;

// integrate some functions
let two_thirds = quad.integrate(-1.0, 1.0, |x| x * x);
assert_abs_diff_eq!(two_thirds, 0.66666, epsilon = eps);

let estimate_sin = quad.integrate(-PI, PI, |x| x.sin());
assert_abs_diff_eq!(estimate_sin, 0.0, epsilon = eps);

// some functions need more steps than others
let m = 100;
let better_quad = Midpoint::new(m)?;

let piecewise = better_quad.integrate(-5.0, 5.0, |x|
    if x > 1.0 && x < 2.0 {
        (-x * x).exp()
    } else {
        0.0
    }
);

assert_abs_diff_eq!(0.135257, piecewise, epsilon = eps);
# Ok::<(), MidpointError>(())
```

--------------------------------

### Rust: Simpson's Rule Integration Example

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/simpson/mod

Demonstrates how to use the Simpson's rule for numerical integration in Rust. It shows initializing the Simpson rule with a specified number of subintervals and integrating functions like exponential and sine, asserting the results against known values using the `approx` crate. The example requires the `gauss_quad::simpson` module and handles potential errors.

```rust
use gauss_quad::simpson::Simpson;
# use gauss_quad::simpson::SimpsonError;
use approx::assert_abs_diff_eq;

use core::f64::consts::PI;

let eps = 0.001;

let n = 10;
let quad = Simpson::new(n)?;

// integrate some functions
let integrate_euler = quad.integrate(0.0, 1.0, |x| x.exp());
assert_abs_diff_eq!(integrate_euler, 1.0_f64.exp() - 1.0, epsilon = eps);

let integrate_sin = quad.integrate(-PI, PI, |x| x.sin());
assert_abs_diff_eq!(integrate_sin, 0.0, epsilon = eps);
# Ok::<(), SimpsonError>(())
```

--------------------------------

### GaussLaguerre Rule Initialization and Integration with Specific Parameters

Source: https://docs.rs/gauss-quad/latest/gauss_quad

Illustrates the specific requirements for initializing the `GaussLaguerre` quadrature rule, which needs a degree and an alpha parameter. It shows an example of integration over the domain [0, ∞) and asserts the result with a given epsilon.

```rust
use gauss_quad::GaussLaguerre;
use std::f64::consts::PI;
use approx::assert_abs_diff_eq;

// initialize the quadrature rule
let degree = 2;
let alpha = 0.5;
let quad = GaussLaguerre::new(degree, alpha)?;

// use the rule to integrate a function
let integral = quad.integrate(|x| x * x);

assert_abs_diff_eq!(integral, 15.0 * PI.sqrt() / 8.0, epsilon = 1e-14);

```

--------------------------------

### Rust: Gauss-Laguerre specific integration

Source: https://docs.rs/gauss-quad/latest/gauss_quad/index

Shows how to initialize and use the Gauss-Laguerre quadrature rule, which requires a degree and an alpha parameter. This rule integrates over the domain [0, ∞) and an example is provided for integrating x^2.

```Rust
use std::f64::consts::PI;
use gauss_quad::GaussLaguerre;
use approx::assert_abs_diff_eq;

// initialize the quadrature rule
let degree = 2;
let alpha = 0.5;
let quad = GaussLaguerre::new(degree, alpha)?;

// use the rule to integrate a function
let integral = quad.integrate(|x| x * x);

assert_abs_diff_eq!(integral, 15.0 * PI.sqrt() / 8.0, epsilon = 1e-14);

```

--------------------------------

### Gauss-Legendre Integration Example in Rust

Source: https://docs.rs/gauss-quad/latest/gauss_quad/legendre/index

Demonstrates how to use the GaussLegendre struct from the gauss_quad crate to perform numerical integration. It requires the `approx` crate for assertion. The function integrates a polynomial of degree 5 over the interval [-1.0, 1.0].

```rust
use gauss_quad::legendre::GaussLegendre;
use approx::assert_abs_diff_eq;

let quad = GaussLegendre::new(10)?;
let integral = quad.integrate(-1.0, 1.0,
    |x| 0.125 * (63.0 * x.powi(5) - 70.0 * x.powi(3) + 15.0 * x)
);
assert_abs_diff_eq!(integral, 0.0);
```

--------------------------------

### Error Handling for Quadrature Rule Initialization in Rust

Source: https://docs.rs/gauss-quad/latest/index

Demonstrates error handling when initializing quadrature rules with invalid parameters. For instance, GaussLaguerre requires a degree greater than 1, and GaussJacobi requires alpha and beta parameters greater than -1.0. The examples use `is_err()` to check for expected errors.

```rust
use gauss_quad::{GaussLaguerre, GaussJacobi};

let degree = 1;
assert!(GaussLaguerre::new(degree, 0.1).is_err());

let degree = 10;
let alpha = 0.1;
let beta = -1.1;

assert!(GaussJacobi::new(degree, alpha, beta).is_err())
```

--------------------------------

### Rust: Error handling for quadrature rules

Source: https://docs.rs/gauss-quad/latest/gauss_quad/index

Demonstrates error handling when initializing quadrature rules from the `gauss_quad` crate. It shows examples of invalid input, such as a degree less than or equal to 1 for Gauss-Laguerre, and invalid alpha/beta parameters for Gauss-Jacobi.

```Rust
use gauss_quad::{GaussLaguerre, GaussJacobi};

let degree = 1;
assert!(GaussLaguerre::new(degree, 0.1).is_err());

let degree = 10;
let alpha = 0.1;
let beta = -1.1;

assert!(GaussJacobi::new(degree, alpha, beta).is_err());

```

--------------------------------

### Performing Double Integrals in Rust using gauss-quad

Source: https://docs.rs/gauss-quad/latest/index

Shows how to perform double integrals by nesting calls to the `integrate` method. The example integrates x²*y over a triangular region. It highlights that the time complexity scales with the number of nodes raised to the power of the integral depth (e.g., O(n³) for triple integrals).

```rust
use gauss_quad::GaussLegendre;
use approx::assert_abs_diff_eq;

let rule = GaussLegendre::new(3)?;

// integrate x^2*y over the triangle in the xy-plane where x ϵ [0, 1] and y ϵ [0, x]:
let double_int = rule.integrate(0.0, 1.0, |x| rule.integrate(0.0, x, |y| x * x * y));

assert_abs_diff_eq!(double_int, 0.1);
```

--------------------------------

### Integrate function using Gauss-Laguerre rule in Rust

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/lib

Shows how to initialize a generalized Gauss-Laguerre quadrature rule with a degree and alpha parameter, and integrate a function (x*x) over its default domain [0, ∞). The example uses `approx` for float comparisons and includes error handling.

```rust
use gauss_quad::laguerre::{GaussLaguerre, GaussLaguerreError};
use approx::assert_abs_diff_eq;
use core::f64::consts::PI;

// initialize the quadrature rule
let degree = 2;
let alpha = 0.5;
let quad = GaussLaguerre::new(degree, alpha)?;

// use the rule to integrate a function
let integral = quad.integrate(|x| x * x);

assert_abs_diff_eq!(integral, 15.0 * PI.sqrt() / 8.0, epsilon = 1e-14);
Ok::<(), GaussLaguerreError>(())
```

--------------------------------

### Example: Integrate x^2 * e^(-x^2)

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/hermite/mod

Demonstrates the usage of the `GaussHermite` quadrature rule to integrate the function x^2 * e^(-x^2) over the domain (-∞, ∞). It initializes a rule with 10 nodes and asserts that the computed integral is approximately equal to the expected value, sqrt(PI) / 2.0.

```rust
use gauss_quad::hermite::GaussHermite;
# use gauss_quad::hermite::GaussHermiteError;
use approx::assert_abs_diff_eq;

let quad = GaussHermite::new(10)?;

let integral = quad.integrate(|x| x.powi(2));

assert_abs_diff_eq!(integral, core::f64::consts::PI.sqrt() / 2.0, epsilon = 1e-14);
# Ok::<(), GaussHermiteError>(())
```

--------------------------------

### Error Handling for Invalid Quadrature Rule Degrees

Source: https://docs.rs/gauss-quad/latest/gauss_quad

Demonstrates how the `gauss-quad` library handles errors when invalid input values are provided for initializing quadrature rules. It shows an example where a degree less than or equal to 1 for `GaussLaguerre` results in an error.

```rust
use gauss_quad::GaussLaguerre;

let degree = 1;
assert!(GaussLaguerre::new(degree, 0.1).is_err());

```

--------------------------------

### GaussLaguerre Integration with Specific Parameters in Rust

Source: https://docs.rs/gauss-quad/latest/index

Shows how to initialize and use the GaussLaguerre quadrature rule with a degree and an alpha parameter. This rule integrates over the domain [0, ∞) and requires the alpha parameter to be greater than -1.0. The example includes an assertion for the calculated integral.

```rust
use gauss_quad::GaussLaguerre;
use std::f64::consts::PI;
use approx::assert_abs_diff_eq;

// initialize the quadrature rule
let degree = 2;
let alpha = 0.5;
let quad = GaussLaguerre::new(degree, alpha)?;

// use the rule to integrate a function
let integral = quad.integrate(|x| x * x);

assert_abs_diff_eq!(integral, 15.0 * PI.sqrt() / 8.0, epsilon = 1e-14);
```

--------------------------------

### Integrating Functions with Closure Arguments in Rust

Source: https://docs.rs/gauss-quad/latest/index

Explains that the `integrate` method of quadrature rules accepts any function or closure that implements the `FnMut(f64) -> f64` trait. This allows for flexible integration of custom mathematical functions. The example shows integrating x*x using a closure.

```rust
use gauss_quad::GaussLegendre;
use approx::assert_abs_diff_eq;

// initialize the quadrature rule
let degree = 2;
let quad = GaussLegendre::new(degree)?;

// use the rule to integrate a function
let left_bound = 0.0;
let right_bound = 1.0;

let integral = quad.integrate(left_bound, right_bound, |x| x * x);

assert_abs_diff_eq!(integral, 1.0 / 3.0);
```

--------------------------------

### GaussJacobi: Integrate Function with Singularity

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/jacobi/mod

Demonstrates integrating a function with a singularity at one of the domain endpoints using GaussJacobi quadrature. The example integrates sin(x) / (1 + x)^(1/3) on the domain [-1, 1], where the weight function handles the singularity at x = -1.

```rust
use gauss_quad::jacobi::GaussJacobi;
use approx::assert_abs_diff_eq;

// Initialize GaussJacobi rule with degree 10, alpha = 0.0, and beta = -1/3.
// This setup is suitable for functions with a (1 + x)^(-1/3) weight factor.
let quad = GaussJacobi::new(10, 0.0, -1.0 / 3.0)?;

// Integrate sin(x) / (1 + x)^(1/3) on the domain [-1, 1].
// The singularity at x = -1 is handled by the beta parameter.
let integral = quad.integrate(-1.0, 1.0, |x| x.sin());

// Assert the computed integral against the known value.
assert_abs_diff_eq!(integral, -0.4207987746500829, epsilon = 1e-14);
Ok::<(), gauss_quad::jacobi::GaussJacobiError>(())
```

--------------------------------

### Integrate with Gauss-Jacobi Rule in Rust

Source: https://docs.rs/gauss-quad/latest/gauss_quad/jacobi/index

This example demonstrates how to use the `GaussJacobi` struct from the `gauss_quad` crate to perform numerical integration. It shows the creation of a quadrature rule with specific parameters and integrates a function with a singularity at one of the endpoints. Dependencies include `gauss_quad` and `approx` for assertions. The function returns the approximated integral value.

```Rust
use gauss_quad::jacobi::GaussJacobi;
use approx::assert_abs_diff_eq;

let quad = GaussJacobi::new(10, 0.0, -1.0 / 3.0)?;

// numerically integrate sin(x) / (1 + x)^(1/3), a function with a singularity at x = -1.
let integral = quad.integrate(-1.0, 1.0, |x| x.sin());

assert_abs_diff_eq!(integral, -0.4207987746500829, epsilon = 1e-14);
```

--------------------------------

### Quadrature Rule Iterator Methods in Rust

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/data_api

This section details the methods available on the `QuadratureRule` struct in Rust. It includes a public `iter` method to get an iterator over nodes, `as_nodes` to get a slice of nodes, `into_nodes` to consume the rule and get a vector of nodes, and `degree` to return the number of nodes.

```rust
impl $quadrature_rule {
    /// Returns an iterator over the nodes of the rule.
    #[inline]
    pub fn iter(&self) -> $quadrature_rule_iter<'_> {
        $quadrature_rule_iter::new(self.nodes.iter())
    }

    /// Returns a slice of all the nodes of the rule.
    #[inline]
    pub fn as_nodes(&self) -> &[$crate::Node] {
        &self.nodes
    }

    /// Converts the rule into a vector of nodes.
    ///
    /// This function just returns the underlying data without any computation or cloning.
    #[inline]
    #[must_use = "`self` will be dropped if the result is not used"]
    pub fn into_nodes(self) -> Vec<$crate::Node> {
        self.nodes
    }

    /// Returns the degree of the rule.
    #[inline]
    pub fn degree(&self) -> usize {
        self.nodes.len()
    }
}
```

--------------------------------

### Untitled

No description

--------------------------------

### Using Different Quadrature Rules in Rust

Source: https://docs.rs/gauss-quad/latest/index

Illustrates the initialization and usage of various quadrature rules provided by the `gauss-quad` crate. Each rule has specific initialization parameters and integration domains. Gauss-Laguerre and Gauss-Hermite perform integration over infinite domains without explicit bounds.

```rust
use gauss_quad::{GaussLegendre, GaussJacobi, GaussLaguerre, GaussHermite};
use std::f64::consts::PI;
use approx::assert_abs_diff_eq;

let degree = 10;
let alpha = 0.5;
let beta = 0.1;
let a = 0.0;
let b = 1.0;
let c = 0.0;
let d = 1.0;

let gauss_legendre = GaussLegendre::new(degree)?;
// Integrate on the domain [a, b]
let x_cubed = gauss_legendre.integrate(a, b, |x| x * x * x);

let gauss_jacobi = GaussJacobi::new(degree, alpha, beta)?;
// Integrate on the domain [c, d]
let double_x = gauss_jacobi.integrate(c, d, |x| 2.0 * x);

let gauss_laguerre = GaussLaguerre::new(degree, alpha)?;
// no explicit domain, Gauss-Laguerre integration is done on the domain [0, ∞).
let piecewise = gauss_laguerre.integrate(|x| if x > 0.0 && x < 2.0 { x } else { 0.0 });

let gauss_hermite = GaussHermite::new(degree)?;
// again, no explicit domain since Gauss-Hermite integration is done over the domain (-∞, ∞).
let golden_polynomial = gauss_hermite.integrate(|x| x * x - x - 1.0);
```

--------------------------------

### Iterating Over Simpson Rule Nodes in Rust

Source: https://docs.rs/gauss-quad/latest/gauss_quad/struct

Demonstrates how to iterate over the nodes of a Simpson's rule. This can be done by either borrowing the Simpson rule to get an iterator or by consuming the Simpson rule to get an iterator. The `SimpsonIter` provides access to node references, while `SimpsonIntoIter` provides owned node values.

```Rust
use gauss_quad::Simpson;

// Assume 'quad' is an initialized Simpson rule

// Iterate over nodes using a reference (SimpsonIter)
for node_ref in &quad {
    // node_ref is of type &f64
    println!("{}", node_ref);
}

// Iterate over nodes by consuming the Simpson rule (SimpsonIntoIter)
// let nodes_values = quad.into_iter().collect::<Vec<f64>>();
```

--------------------------------

### Rust: Integrate function with Gauss-Legendre

Source: https://docs.rs/gauss-quad/latest/gauss_quad/index

Demonstrates initializing a Gauss-Legendre quadrature rule and using it to integrate a function over a specified domain. It requires the `gauss_quad` crate and optionally `approx` for assertions.

```Rust
use gauss_quad::GaussLegendre;
use approx::assert_abs_diff_eq;

// initialize the quadrature rule
let degree = 10;
let quad = GaussLegendre::new(degree)?;

// use the rule to integrate a function
let left_bound = 0.0;
let right_bound = 1.0;
let integral = quad.integrate(left_bound, right_bound, |x| x * x);
assert_abs_diff_eq!(integral, 1.0 / 3.0);

```

--------------------------------

### Initialize and Integrate with GaussLegendre Rule in Rust

Source: https://docs.rs/gauss-quad/latest/index

Demonstrates how to initialize a GaussLegendre quadrature rule with a specified degree and use it to integrate a function over a given interval. It requires the `approx` crate for assertions. The `integrate` method takes the left and right bounds and a closure representing the function to integrate.

```rust
use gauss_quad::GaussLegendre;
use approx::assert_abs_diff_eq;

// initialize the quadrature rule
let degree = 10;
let quad = GaussLegendre::new(degree)?;

// use the rule to integrate a function
let left_bound = 0.0;
let right_bound = 1.0;
let integral = quad.integrate(left_bound, right_bound, |x| x * x);
assert_abs_diff_eq!(integral, 1.0 / 3.0);
```

--------------------------------

### Get Pointer Alignment

Source: https://docs.rs/gauss-quad/latest/gauss_quad/midpoint/struct

Returns the required alignment in bytes for a type `T` when used with pointer-based operations. This is a `const` associated with the `Pointable` trait.

```rust
const ALIGN: usize
```

--------------------------------

### Using Different Quadrature Rules for Integration

Source: https://docs.rs/gauss-quad/latest/gauss_quad

Shows the initialization and usage of various quadrature rules provided by the `gauss-quad` crate, including Gauss-Legendre, Gauss-Jacobi, Gauss-Laguerre, and Gauss-Hermite. Different rules accept different parameters and have specific domain considerations.

```rust
let degree = 10;
let alpha = 0.5; // Example alpha for GaussJacobi and GaussLaguerre
let beta = 0.2;  // Example beta for GaussJacobi
let a = 0.0;     // Example domain start
let b = 1.0;     // Example domain end
let c = 2.0;     // Example domain start for another interval
let d = 3.0;     // Example domain end for another interval

let gauss_legendre = GaussLegendre::new(degree)?;
// Integrate on the domain [a, b]
let x_cubed = gauss_legendre.integrate(a, b, |x| x * x * x);

let gauss_jacobi = GaussJacobi::new(degree, alpha, beta)?;
// Integrate on the domain [c, d]
let double_x = gauss_jacobi.integrate(c, d, |x| 2.0 * x);

let gauss_laguerre = GaussLaguerre::new(degree, alpha)?;
// no explicit domain, Gauss-Laguerre integration is done on the domain [0, ∞).
let piecewise = gauss_laguerre.integrate(|x| if x > 0.0 && x < 2.0 { x } else { 0.0 });

let gauss_hermite = GaussHermite::new(degree)?;
// again, no explicit domain since Gauss-Hermite integration is done over the domain (-∞, ∞).
let golden_polynomial = gauss_hermite.integrate(|x| x * x - x - 1.0);

```

--------------------------------

### Using various quadrature rules in Rust

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/lib

Illustrates the initialization and usage of different quadrature rules like GaussLegendre, GaussJacobi, GaussLaguerre, and GaussHermite. It shows how to integrate functions over specified domains, noting that GaussLaguerre and GaussHermite integrate over implicit domains [0, ∞) and (-∞, ∞) respectively.

```rust
use gauss_quad::*;

let degree = 5;
let alpha = 1.2;
let beta = 1.2;
let a = 0.0;
let b = 1.0;
let c = -10.;
let d = 100.;

let gauss_legendre = GaussLegendre::new(degree)?;
// Integrate on the domain [a, b]
let x_cubed = gauss_legendre.integrate(a, b, |x| x * x * x);

let gauss_jacobi = GaussJacobi::new(degree, alpha, beta)?;
// Integrate on the domain [c, d]
let double_x = gauss_jacobi.integrate(c, d, |x| 2.0 * x);

let gauss_laguerre = GaussLaguerre::new(degree, alpha)?;
// no explicit domain, Gauss-Laguerre integration is done on the domain [0, ∞).
let piecewise = gauss_laguerre.integrate(|x| if x > 0.0 && x < 2.0 { x } else { 0.0 });

let gauss_hermite = GaussHermite::new(degree)?;
// again, no explicit domain since Gauss-Hermite integration is done over the domain (-∞, ∞).
let golden_polynomial = gauss_hermite.integrate(|x| x * x - x - 1.0);
Ok::<(), Box<dyn std::error::Error>>(())
```

--------------------------------

### Get TypeId of Self (Rust)

Source: https://docs.rs/gauss-quad/latest/gauss_quad/laguerre/struct

The `type_id` function returns the `TypeId` of the current type. This is useful for runtime type introspection and comparison.

```Rust
fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
Source§
```

--------------------------------

### Get Type ID

Source: https://docs.rs/gauss-quad/latest/gauss_quad/hermite/struct

The `type_id` method, part of the `Any` trait implementation, returns the `TypeId` of an object. This is useful for runtime type identification and dynamic dispatch scenarios.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Untitled

No description

--------------------------------

### Simpson Rule Initialization and Integration in Rust

Source: https://docs.rs/gauss-quad/latest/gauss_quad/struct

Demonstrates how to initialize a Simpson's rule with a specified degree and then use it to numerically integrate a function over a given interval. This requires the `gauss-quad` crate. The `integrate` method takes the interval bounds and a closure representing the integrand.

```Rust
use gauss_quad::Simpson;

// Initialize a Simpson rule with 100 subintervals
let quad: Simpson = Simpson::new(100)?;

// Numerically integrate a function from -1.0 to 1.0 using the Simpson rule
let approx = quad.integrate(-1.0, 1.0, |x| x * x);
```

--------------------------------

### Midpoint Rule Integration Implementation

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/midpoint/mod

The core implementation of the midpoint rule for numerical integration. It calculates the width of each rectangular section and sums the function evaluations at the midpoints, then multiplies by the rectangle width to get the integral approximation.

```rust
pub fn integrate<F>(&self, a: f64, b: f64, mut integrand: F) -> f64
where
    F: FnMut(f64) -> f64,
{
    let rect_width = (b - a) / self.nodes.len() as f64;

    let sum: f64 = self
        .nodes
        .iter()
        .map(|&node| integrand(a + rect_width * (0.5 + node)))
        .sum();

    sum * rect_width
}
```

--------------------------------

### Rust: Simpson Rule Initialization and Integration

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/simpson/mod

Illustrates the basic usage of the Simpson's rule in Rust for numerical integration. It covers initializing a `Simpson` instance with a given number of subintervals and then calling the `integrate` method to approximate the integral of a function (e.g., x*x) over a specified domain. Error handling for initialization is also shown.

```rust
# use gauss_quad::simpson::{Simpson, SimpsonError};
// initialize a Simpson rule with 100 subintervals
let quad: Simpson = Simpson::new(100)?;

// numerically integrate a function from -1.0 to 1.0 using the Simpson rule
let approx = quad.integrate(-1.0, 1.0, |x| x * x);
# Ok::<(), SimpsonError>(())
```

--------------------------------

### Rust: Passing functions to quadrature rules

Source: https://docs.rs/gauss-quad/latest/gauss_quad/index

Illustrates how to pass a closure (implementing `FnMut(f64) -> f64`) as the integrand to the `integrate` method of a quadrature rule in the `gauss_quad` crate. This example uses Gauss-Legendre to integrate x^2.

```Rust
use gauss_quad::GaussLegendre;
use approx::assert_abs_diff_eq;

// initialize the quadrature rule
let degree = 2;
let quad = GaussLegendre::new(degree)?;

// use the rule to integrate a function
let left_bound = 0.0;
let right_bound = 1.0;

let integral = quad.integrate(left_bound, right_bound, |x| x * x);

assert_abs_diff_eq!(integral, 1.0 / 3.0);

```

--------------------------------

### Get Superset Element as Subset

Source: https://docs.rs/gauss-quad/latest/gauss_quad/midpoint/struct

Attempts to convert a superset element (`SP`) into its equivalent subset element (`SS`). This operation returns an `Option<SS>` and may fail if the superset element does not conform to the subset's properties.

```rust
fn to_subset(&self) -> Option<SS>
where
    SS: SubsetOf<SP>,
```

--------------------------------

### Iterator Methods

Source: https://docs.rs/gauss-quad/latest/gauss_quad/hermite/struct

This section details common iterator methods available for GaussHermiteWeights, including next, size_hint, nth, count, last, and more.

```APIDOC
## Iterator Methods

### `next(&mut self) -> Option<Self::Item>`
Advances the iterator and returns the next value.

### `size_hint(&self) -> (usize, Option<usize>)`
Returns the bounds on the remaining length of the iterator.

### `nth(&mut self, index: usize) -> Option<Self::Item>`
Returns the `n`th element of the iterator.

### `count(self) -> usize`
Consumes the iterator, counting the number of iterations and returning it.

### `last(self) -> Option<Self::Item>`
Consumes the iterator, returning the last element.

### `advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>`
Advances the iterator by `n` elements. (Nightly-only experimental API)

### `step_by(self, step: usize) -> StepBy<Self>`
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

### `chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>`
Takes two iterators and creates a new iterator over both in sequence.

### `zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>`
‘Zips up’ two iterators into a single iterator of pairs.

### `intersperse(self, separator: Self::Item) -> Intersperse<Self>`
Creates a new iterator which places a copy of `separator` between adjacent items of the original iterator. (Nightly-only experimental API)

### `intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>`
Creates a new iterator which places an item generated by `separator` between adjacent items of the original iterator. (Nightly-only experimental API)
```

--------------------------------

### Accessing Simpson Rule Nodes in Rust

Source: https://docs.rs/gauss-quad/latest/gauss_quad/struct

Illustrates how to access the nodes used by the Simpson's rule for integration. You can either get a slice of all nodes or convert the rule into a vector of nodes. This can be useful for understanding the underlying quadrature points.

```Rust
use gauss_quad::Simpson;

// Assume 'quad' is an initialized Simpson rule

// Get a slice of all nodes
let nodes_slice = quad.as_nodes();

// Convert the rule into a vector of nodes
let nodes_vec = quad.into_nodes();
```

--------------------------------

### GaussHermite Initialization and Iteration Test

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/hermite/mod

Tests the initialization of `GaussHermite::new(3)` and verifies the accuracy of the generated nodes and weights against expected values using `approx::assert_abs_diff_eq` for floating-point comparisons. It also demonstrates unzipping the iterator into separate node and weight vectors.

```rust
#[test]
fn golub_welsch_3() {
    let (x, w): (Vec<_>, Vec<_>) = GaussHermite::new(3).unwrap().into_iter().unzip();
    let x_should = [1.224_744_871_391_589, 0.0, -1.224_744_871_391_589];
    let w_should = [
        0.295_408_975_150_919_35,
        1.181_635_900_603_677_4,
        0.295_408_975_150_919_35,
    ];
    for (i, x_val) in x_should.iter().enumerate() {
        assert_abs_diff_eq!(*x_val, x[i], epsilon = 1e-15);
    }
    for (i, w_val) in w_should.iter().enumerate() {
        assert_abs_diff_eq!(*w_val, w[i], epsilon = 1e-15);
    }
}
```

--------------------------------

### Untitled

No description

--------------------------------

### Untitled

No description

--------------------------------

### Untitled

No description

--------------------------------

### Parallel Initialization of Gauss-Legendre Rule (Rust)

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/legendre/mod

Initializes a Gauss-Legendre quadrature rule of a specified degree in parallel. This is an optimized version of `new` for environments where parallel processing is beneficial. It also requires a minimum degree of 2.

```rust
#[cfg(feature = "rayon")]
    /// Same as [`new`](GaussLegendre::new) but runs in parallel.
    ///
    /// # Errors
    ///
    /// Returns an error if `deg` is smaller than 2.
    pub fn par_new(deg: usize) -> Result<Self, GaussLegendreError> {
        if deg < 2 {
            return Err(GaussLegendreError::new());
        }

        Ok(Self {
            node_weight_pairs: (1..deg + 1)
                .into_par_iter()
                .map(|k| NodeWeightPair::new(deg, k).into_tuple())
                .collect(),
        })
    }
```

--------------------------------

### Error handling for GaussJacobi initialization in Rust

Source: https://docs.rs/gauss-quad/latest/src/gauss_quad/lib

Illustrates error handling for the GaussJacobi quadrature rule in Rust. It shows that initializing the rule with alpha or beta parameters less than or equal to -1.0 results in an error.

```rust
use gauss_quad::jacobi::GaussJacobi;

let degree = 10;
let alpha = 0.1;
let beta = -1.1;

assert!(GaussJacobi::new(degree, alpha, beta).is_err())
```
Tokens:
Raw