86 lines
2.5 KiB
Go
86 lines
2.5 KiB
Go
package numerics
|
|
|
|
import "fmt"
|
|
|
|
// Axis describes a regularly-spaced grid axis with N grid points,
|
|
// values left, left+step, left+2*step, ..., left+(N-1)*step.
|
|
//
|
|
// If Wrap is true, the axis is periodic with period N*step (e.g. longitude).
|
|
// A query value at left+N*step wraps to the value at left+0*step. Locate
|
|
// returns Hi = 0 in that case.
|
|
type Axis struct {
|
|
Left float64
|
|
Step float64
|
|
N int
|
|
Wrap bool
|
|
Name string
|
|
}
|
|
|
|
// AxisError is returned by Axis.Locate when value lies outside a non-wrapping axis.
|
|
type AxisError struct {
|
|
Axis string
|
|
Value float64
|
|
}
|
|
|
|
func (e *AxisError) Error() string {
|
|
return fmt.Sprintf("%s=%v out of range", e.Axis, e.Value)
|
|
}
|
|
|
|
// Bracket holds the two surrounding grid indices and the fractional position
|
|
// of a value within an axis. The weight at Lo is (1 - Frac); the weight at Hi
|
|
// is Frac. Frac lies in [0, 1).
|
|
type Bracket struct {
|
|
Lo, Hi int
|
|
Frac float64
|
|
}
|
|
|
|
// Locate returns the bracket containing value within the axis.
|
|
// For a non-wrapping axis, value must lie in [Left, Left + (N-1)*Step);
|
|
// for a wrapping axis, value must lie in [Left, Left + N*Step).
|
|
func (a Axis) Locate(value float64) (Bracket, error) {
|
|
pos := (value - a.Left) / a.Step
|
|
lo := int(pos) // truncates toward zero; pos is non-negative for valid inputs
|
|
|
|
maxLo := a.N - 2
|
|
if a.Wrap {
|
|
maxLo = a.N - 1
|
|
}
|
|
if lo < 0 || lo > maxLo {
|
|
return Bracket{}, &AxisError{Axis: a.Name, Value: value}
|
|
}
|
|
|
|
hi := lo + 1
|
|
if a.Wrap && hi == a.N {
|
|
hi = 0
|
|
}
|
|
return Bracket{Lo: lo, Hi: hi, Frac: pos - float64(lo)}, nil
|
|
}
|
|
|
|
// EvalTrilinear samples a 3D field via f at the eight corners defined by b3
|
|
// and returns the trilinearly interpolated value.
|
|
//
|
|
// The corners are visited in the order (axis0 outer, axis2 inner), matching
|
|
// the Cython reference. With f(i,j,k) = a*i + b*j + c*k + d this returns
|
|
// a*pos0 + b*pos1 + c*pos2 + d exactly, modulo floating-point rounding.
|
|
func EvalTrilinear(b3 [3]Bracket, f func(i, j, k int) float64) float64 {
|
|
wa0, wa1 := 1-b3[0].Frac, b3[0].Frac
|
|
wb0, wb1 := 1-b3[1].Frac, b3[1].Frac
|
|
wc0, wc1 := 1-b3[2].Frac, b3[2].Frac
|
|
a0, a1 := b3[0].Lo, b3[0].Hi
|
|
bb0, bb1 := b3[1].Lo, b3[1].Hi
|
|
c0, c1 := b3[2].Lo, b3[2].Hi
|
|
|
|
return wa0*wb0*wc0*f(a0, bb0, c0) +
|
|
wa0*wb0*wc1*f(a0, bb0, c1) +
|
|
wa0*wb1*wc0*f(a0, bb1, c0) +
|
|
wa0*wb1*wc1*f(a0, bb1, c1) +
|
|
wa1*wb0*wc0*f(a1, bb0, c0) +
|
|
wa1*wb0*wc1*f(a1, bb0, c1) +
|
|
wa1*wb1*wc0*f(a1, bb1, c0) +
|
|
wa1*wb1*wc1*f(a1, bb1, c1)
|
|
}
|
|
|
|
// Lerp returns (1-l)*a + l*b.
|
|
func Lerp(a, b, l float64) float64 {
|
|
return (1-l)*a + l*b
|
|
}
|