Documentation

Overview

    Package hyperdual provides the hyperdual numeric type and functions. Hyperdual numbers are an extension of the real numbers in the form a+bϵ₁+bϵ₂+dϵ₁ϵ₂ where ϵ₁^2=0 and ϵ₂^2=0, but ϵ₁≠0, ϵ₂≠0 and ϵ₁ϵ₂≠0.

    See https://doi.org/10.2514/6.2011-886 and http://adl.stanford.edu/hyperdual/ for details of their properties and uses.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Number

    type Number struct {
    	Real, E1mag, E2mag, E1E2mag float64
    }

      Number is a float64 precision hyperdual number.

      Example (Fike)
      Output:
      
      
      v=(4.4978+4.0534ϵ₁+4.0534ϵ₂+9.4631ϵ₁ϵ₂)
      fn(1.5)=4.4978
      fn'(1.5)=4.0534
      fn''(1.5)=9.4631
      

      func Abs

      func Abs(d Number) Number

        Abs returns the absolute value of d.

        func Acos

        func Acos(d Number) Number

          Acos returns the inverse cosine of d.

          Special cases are:

          Acos(-1) = (Pi-Infϵ₁-Infϵ₂+Infϵ₁ϵ₂)
          Acos(1) = (0-Infϵ₁-Infϵ₂-Infϵ₁ϵ₂)
          Acos(x) = NaN if x < -1 or x > 1
          

          func Acosh

          func Acosh(d Number) Number

            Acosh returns the inverse hyperbolic cosine of d.

            Special cases are:

            Acosh(+Inf) = +Inf
            Acosh(1) = (0+Infϵ₁+Infϵ₂-Infϵ₁ϵ₂)
            Acosh(x) = NaN if x < 1
            Acosh(NaN) = NaN
            

            func Add

            func Add(x, y Number) Number

              Add returns the sum of x and y.

              func Asin

              func Asin(d Number) Number

                Asin returns the inverse sine of d.

                Special cases are:

                Asin(±0) = (±0+Nϵ₁+Nϵ₂±0ϵ₁ϵ₂)
                Asin(±1) = (±Inf+Infϵ₁+Infϵ₂±Infϵ₁ϵ₂)
                Asin(x) = NaN if x < -1 or x > 1
                

                func Asinh

                func Asinh(d Number) Number

                  Asinh returns the inverse hyperbolic sine of d.

                  Special cases are:

                  Asinh(±0) = (±0+Nϵ₁+Nϵ₂∓0ϵ₁ϵ₂)
                  Asinh(±Inf) = ±Inf
                  Asinh(NaN) = NaN
                  

                  func Atan

                  func Atan(d Number) Number

                    Atan returns the inverse tangent of d.

                    Special cases are:

                    Atan(±0) = (±0+Nϵ₁+Nϵ₂∓0ϵ₁ϵ₂)
                    Atan(±Inf) = (±Pi/2+0ϵ₁+0ϵ₂∓0ϵ₁ϵ₂)
                    

                    func Atanh

                    func Atanh(d Number) Number

                      Atanh returns the inverse hyperbolic tangent of d.

                      Special cases are:

                      Atanh(1) = +Inf
                      Atanh(±0) = (±0+Nϵ₁+Nϵ₂±0ϵ₁ϵ₂)
                      Atanh(-1) = -Inf
                      Atanh(x) = NaN if x < -1 or x > 1
                      Atanh(NaN) = NaN
                      

                      func Cos

                      func Cos(d Number) Number

                        Cos returns the cosine of d.

                        Special cases are:

                        Cos(±Inf) = NaN
                        Cos(NaN) = NaN
                        

                        func Cosh

                        func Cosh(d Number) Number

                          Cosh returns the hyperbolic cosine of d.

                          Special cases are:

                          Cosh(±0) = 1
                          Cosh(±Inf) = +Inf
                          Cosh(NaN) = NaN
                          

                          func Exp

                          func Exp(d Number) Number

                            Exp returns e**q, the base-e exponential of d.

                            Special cases are:

                            Exp(+Inf) = +Inf
                            Exp(NaN) = NaN
                            

                            Very large values overflow to 0 or +Inf. Very small values underflow to 1.

                            func Inv

                            func Inv(d Number) Number

                              Inv returns the hyperdual inverse of d.

                              Special cases are:

                              Inv(±Inf) = ±0-0ϵ₁-0ϵ₂±0ϵ₁ϵ₂
                              Inv(±0) = ±Inf-Infϵ₁-Infϵ₂±Infϵ₁ϵ₂
                              

                              func Log

                              func Log(d Number) Number

                                Log returns the natural logarithm of d.

                                Special cases are:

                                Log(+Inf) = (+Inf+0ϵ₁+0ϵ₂-0ϵ₁ϵ₂)
                                Log(0) = (-Inf±Infϵ₁±Infϵ₂-Infϵ₁ϵ₂)
                                Log(x < 0) = NaN
                                Log(NaN) = NaN
                                

                                func Mul

                                func Mul(x, y Number) Number

                                  Mul returns the hyperdual product of x and y.

                                  func Pow

                                  func Pow(d, p Number) Number

                                    Pow returns x**p, the base-x exponential of p.

                                    func PowReal

                                    func PowReal(d Number, p float64) Number

                                      PowReal returns x**p, the base-x exponential of p.

                                      Special cases are (in order):

                                      PowReal(NaN+xϵ₁+yϵ₂, ±0) = 1+NaNϵ₁+NaNϵ₂+NaNϵ₁ϵ₂ for any x and y
                                      PowReal(x, ±0) = 1 for any x
                                      PowReal(1+xϵ₁+yϵ₂, z) = 1+xzϵ₁+yzϵ₂+2xyzϵ₁ϵ₂ for any z
                                      PowReal(NaN+xϵ₁+yϵ₂, 1) = NaN+xϵ₁+yϵ₂+NaNϵ₁ϵ₂ for any x
                                      PowReal(x, 1) = x for any x
                                      PowReal(NaN+xϵ₁+xϵ₂, y) = NaN+NaNϵ₁+NaNϵ₂+NaNϵ₁ϵ₂
                                      PowReal(x, NaN) = NaN+NaNϵ₁+NaNϵ₂+NaNϵ₁ϵ₂
                                      PowReal(±0, y) = ±Inf for y an odd integer < 0
                                      PowReal(±0, -Inf) = +Inf
                                      PowReal(±0, +Inf) = +0
                                      PowReal(±0, y) = +Inf for finite y < 0 and not an odd integer
                                      PowReal(±0, y) = ±0 for y an odd integer > 0
                                      PowReal(±0, y) = +0 for finite y > 0 and not an odd integer
                                      PowReal(-1, ±Inf) = 1
                                      PowReal(x+0ϵ₁+0ϵ₂, +Inf) = +Inf+NaNϵ₁+NaNϵ₂+NaNϵ₁ϵ₂ for |x| > 1
                                      PowReal(x+xϵ₁+yϵ₂, +Inf) = +Inf+Infϵ₁+Infϵ₂+NaNϵ₁ϵ₂ for |x| > 1
                                      PowReal(x, -Inf) = +0+NaNϵ₁+NaNϵ₂+NaNϵ₁ϵ₂ for |x| > 1
                                      PowReal(x+yϵ₁+zϵ₂, +Inf) = +0+NaNϵ₁+NaNϵ₂+NaNϵ₁ϵ₂ for |x| < 1
                                      PowReal(x+0ϵ₁+0ϵ₂, -Inf) = +Inf+NaNϵ₁+NaNϵ₂+NaNϵ₁ϵ₂ for |x| < 1
                                      PowReal(x, -Inf) = +Inf-Infϵ₁-Infϵ₂+NaNϵ₁ϵ₂ for |x| < 1
                                      PowReal(+Inf, y) = +Inf for y > 0
                                      PowReal(+Inf, y) = +0 for y < 0
                                      PowReal(-Inf, y) = Pow(-0, -y)
                                      PowReal(x, y) = NaN+NaNϵ₁+NaNϵ₂+NaNϵ₁ϵ₂ for finite x < 0 and finite non-integer y
                                      

                                      func Scale

                                      func Scale(f float64, d Number) Number

                                        Scale returns d scaled by f.

                                        func Sin

                                        func Sin(d Number) Number

                                          Sin returns the sine of d.

                                          Special cases are:

                                          Sin(±0) = (±0+Nϵ₁+Nϵ₂∓0ϵ₁ϵ₂)
                                          Sin(±Inf) = NaN
                                          Sin(NaN) = NaN
                                          

                                          func Sinh

                                          func Sinh(d Number) Number

                                            Sinh returns the hyperbolic sine of d.

                                            Special cases are:

                                            Sinh(±0) = (±0+Nϵ₁+Nϵ₂±0ϵ₁ϵ₂)
                                            Sinh(±Inf) = ±Inf
                                            Sinh(NaN) = NaN
                                            

                                            func Sqrt

                                            func Sqrt(d Number) Number

                                              Sqrt returns the square root of d.

                                              Special cases are:

                                              Sqrt(+Inf) = +Inf
                                              Sqrt(±0) = (±0+Infϵ₁+Infϵ₂-Infϵ₁ϵ₂)
                                              Sqrt(x < 0) = NaN
                                              Sqrt(NaN) = NaN
                                              

                                              func Sub

                                              func Sub(x, y Number) Number

                                                Sub returns the difference of x and y, x-y.

                                                func Tan

                                                func Tan(d Number) Number

                                                  Tan returns the tangent of d.

                                                  Special cases are:

                                                  Tan(±0) = (±0+Nϵ₁+Nϵ₂±0ϵ₁ϵ₂)
                                                  Tan(±Inf) = NaN
                                                  Tan(NaN) = NaN
                                                  

                                                  func Tanh

                                                  func Tanh(d Number) Number

                                                    Tanh returns the hyperbolic tangent of d.

                                                    Special cases are:

                                                    Tanh(±0) = (±0+Nϵ₁+Nϵ₂∓0ϵ₁ϵ₂)
                                                    Tanh(±Inf) = (±1+0ϵ₁+0ϵ₂∓0ϵ₁ϵ₂)
                                                    Tanh(NaN) = NaN
                                                    

                                                    func (Number) Format

                                                    func (d Number) Format(fs fmt.State, c rune)

                                                      Format implements fmt.Formatter.