package
Version: v0.11.0 Latest Latest

Go to latest
Published: Mar 16, 2022 License: BSD-3-Clause

## Documentation ¶

### Overview ¶

Package quad provides numerical evaluation of definite integrals of single-variable functions.

Example
package main

import (
"fmt"
"math"
"runtime"

"gonum.org/v1/gonum/stat/distuv"
)

func main() {
fmt.Println("Evaluate the expected value of x^2 + 3 under a Weibull distribution")
f := func(x float64) float64 {
d := distuv.Weibull{Lambda: 1, K: 1.5}
return (x*x + 3) * d.Prob(x)
}
ev := quad.Fixed(f, 0, math.Inf(1), 10, nil, 0)
fmt.Printf("EV with 10 points = %0.6v\n", ev)

ev = quad.Fixed(f, 0, math.Inf(1), 30, nil, 0)
fmt.Printf("EV with 30 points = %0.6v\n", ev)

ev = quad.Fixed(f, 0, math.Inf(1), 100, nil, 0)
fmt.Printf("EV with 100 points = %0.6v\n", ev)

ev = quad.Fixed(f, 0, math.Inf(1), 10000, nil, 0)
fmt.Printf("EV with 10000 points = %0.6v\n\n", ev)

fmt.Println("Estimate using parallel evaluations of f.")
concurrent := runtime.GOMAXPROCS(0)
ev = quad.Fixed(f, 0, math.Inf(1), 100, nil, concurrent)
fmt.Printf("EV = %0.6v\n", ev)
}

Output:

Evaluate the expected value of x^2 + 3 under a Weibull distribution
EV with 10 points = 4.20175
EV with 30 points = 4.19066
EV with 100 points = 4.19064
EV with 10000 points = 4.19064

Estimate using parallel evaluations of f.
EV = 4.19064


### Constants ¶

This section is empty.

### Variables ¶

This section is empty.

### Functions ¶

#### func Fixed ¶

func Fixed(f func(float64) float64, min, max float64, n int, rule FixedLocationer, concurrent int) float64

Fixed approximates the integral of the function f from min to max using a fixed n-point quadrature rule. During evaluation, f will be evaluated n times using the weights and locations specified by rule. That is, Fixed estimates

int_min^max f(x) dx ≈ \sum_i w_i f(x_i)


If rule is nil, an acceptable default is chosen, otherwise it is assumed that the properties of the integral match the assumptions of rule. For example, Legendre assumes that the integration bounds are finite. If rule is also a FixedLocationSingler, the quadrature points are computed individually rather than as a unit.

If concurrent <= 0, f is evaluated serially, while if concurrent > 0, f may be evaluated with at most concurrent simultaneous evaluations.

min must be less than or equal to max, and n must be positive, otherwise Fixed will panic.

### Types ¶

#### type FixedLocationSingler ¶

type FixedLocationSingler interface {
FixedLocationSingle(n, k int, min, max float64) (x, weight float64)
}

FixedLocationSingle returns the location and weight for element k in a fixed quadrature rule with n total samples and integral bounds from min to max.

#### type FixedLocationer ¶

type FixedLocationer interface {
FixedLocations(x, weight []float64, min, max float64)
}

FixedLocationer computes a set of quadrature locations and weights and stores them in-place into x and weight respectively. The number of points generated is equal to the len(x). The weights and locations should be chosen such that

int_min^max f(x) dx ≈ \sum_i w_i f(x_i)


#### type Hermite ¶

type Hermite struct{}

Hermite generates sample locations and weights for performing quadrature with a squared-exponential weight

int_-inf^inf e^(-x^2) f(x) dx .


#### func (Hermite) FixedLocations ¶

func (h Hermite) FixedLocations(x, weight []float64, min, max float64)

#### type Legendre ¶

type Legendre struct{}

Legendre integrates an unweighted function over finite bounds

int_min^max f(x) dx


#### func (Legendre) FixedLocationSingle ¶

func (l Legendre) FixedLocationSingle(n, k int, min, max float64) (x, weight float64)

#### func (Legendre) FixedLocations ¶

func (l Legendre) FixedLocations(x, weight []float64, min, max float64)