forked from tsai/mathnet-numerics
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
417 lines
11 KiB
417 lines
11 KiB
// First version copied from the F# Power Pack
|
|
// https://raw.github.com/fsharp/powerpack/master/src/FSharp.PowerPack/math/complex.fs
|
|
// (c) Microsoft Corporation 2005-2009.
|
|
|
|
namespace MathNet.Numerics
|
|
|
|
open Microsoft.FSharp.Math
|
|
open System
|
|
open System.Globalization
|
|
|
|
#if NOSYSNUMERICS
|
|
#else
|
|
open System.Numerics
|
|
#endif
|
|
|
|
//
|
|
type complex = Complex
|
|
//
|
|
type complex32 = Complex32
|
|
|
|
//
|
|
[<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
|
|
module Complex =
|
|
/// Create a complex number using real and imaginary parts
|
|
let mkRect(a,b) = Complex(a,b)
|
|
|
|
/// Create a complex number using magnitude/phase polar coordinates
|
|
let mkPolar(a,b) = Complex.FromPolarCoordinates(a,b)
|
|
|
|
/// A complex of magnitude 1 and the given phase and , i.e. cis x = mkPolar 1.0 x
|
|
let cis b = mkPolar(1.0,b)
|
|
|
|
//
|
|
let private ofComplex32 (x : complex32) =
|
|
Complex(float x.Real, float x.Imaginary)
|
|
|
|
/// The complex number 0+0i
|
|
let zero = Complex.Zero
|
|
|
|
/// The complex number 1+0i
|
|
let one = Complex.One
|
|
|
|
/// The complex number 0+1i
|
|
let onei = Complex.ImaginaryOne
|
|
|
|
/// pi
|
|
let pi = mkRect (Math.PI,0.0)
|
|
|
|
|
|
/// The real part of a complex number
|
|
let realPart (c:complex) = c.Real
|
|
|
|
/// The imaginary part of a complex number
|
|
let imagPart (c:complex) = c.Imaginary
|
|
|
|
/// The polar-coordinate magnitude of a complex number
|
|
let magnitude (c:complex) = c.Magnitude
|
|
|
|
/// The polar-coordinate phase of a complex number
|
|
let phase (c:complex) = c.Phase
|
|
|
|
|
|
/// Unary negation of a complex number
|
|
let neg (a:complex) = -a
|
|
|
|
/// The conjugate of a complex number, i.e. x-yi
|
|
let conjugate (c:complex) = c.Conjugate()
|
|
|
|
|
|
/// Add two complex numbers
|
|
let add (a:complex) (b:complex) = a + b
|
|
|
|
/// Subtract one complex number from another
|
|
let sub (a:complex) (b:complex) = a - b
|
|
|
|
/// Multiply two complex numbers
|
|
let mul (a:complex) (b:complex) = a * b
|
|
|
|
/// Complex division of two complex numbers
|
|
let div (x:complex) (y:complex) = x / y
|
|
|
|
|
|
/// Multiply a scalar by a complex number
|
|
let smul (a:float) (b:complex) = new Complex(a * b.Real, a * b.Imaginary)
|
|
|
|
/// Multiply a complex number by a scalar
|
|
let muls (a:complex) (b:float) = new Complex(a.Real * b, a.Imaginary * b)
|
|
|
|
|
|
/// exp(x) = e^x
|
|
let exp (x:complex) = Complex.Exp(x)
|
|
|
|
/// ln(x) is natural log (base e)
|
|
let ln x = Complex.Log(x)
|
|
|
|
/// log10(x) is common log (base 10)
|
|
let log10 x = Complex.Log10(x)
|
|
|
|
/// log(base,x) is log with custom base
|
|
let log b x = Complex.Log(x,b)
|
|
|
|
/// pow(power,x) is the complex power
|
|
let pow (power : complex) x = Complex.Pow(x,power)
|
|
|
|
/// pow(power,x) is the scalar power
|
|
let powf (power : float) x = Complex.Pow(x,power)
|
|
|
|
/// sqr(x) is the square (power 2)
|
|
let sqr (x : complex) = x.Square()
|
|
|
|
/// sqrt(x) and 0 <= phase(x) < pi
|
|
let sqrt (x : complex) = x.SquareRoot() // numerically more stable than Complex.Sqrt
|
|
|
|
|
|
/// Sine
|
|
let sin x = Complex.Sin(x)
|
|
|
|
/// Cosine
|
|
let cos x = Complex.Cos(x)
|
|
|
|
/// Tangent
|
|
let tan x = Complex.Tan(x)
|
|
|
|
/// Cotangent
|
|
let cot (x : complex) = Trig.Cot(x)
|
|
|
|
/// Secant
|
|
let sec (x : complex) = Trig.Sec(x)
|
|
|
|
/// Cosecant
|
|
let csc (x : complex) = Trig.Csc(x)
|
|
|
|
|
|
/// Arc Sine
|
|
let asin (x : complex) =
|
|
// numerically more stable than Complex.Asin
|
|
Trig.Asin(x)
|
|
|
|
/// Arc Cosine
|
|
let acos (x : complex) =
|
|
// numerically more stable than Complex.Acos
|
|
Trig.Acos(x)
|
|
|
|
/// Arc Tangent
|
|
let atan x = Complex.Atan(x)
|
|
|
|
/// Arc Cotangent
|
|
let acot (x : complex) = Trig.Acot(x)
|
|
|
|
/// Arc Secant
|
|
let asec (x : complex) = Trig.Asec(x)
|
|
|
|
/// Arc Cosecant
|
|
let acsc (x : complex) = Trig.Acsc(x)
|
|
|
|
|
|
/// Hyperbolic Sine
|
|
let sinh x = Complex.Sinh(x)
|
|
|
|
/// Hyperbolic Cosine
|
|
let cosh x = Complex.Cosh(x)
|
|
|
|
/// Hyperbolic Tangent
|
|
let tanh x = Complex.Tanh(x)
|
|
|
|
/// Hyperbolic Cotangent
|
|
let coth (x : complex) = Trig.Coth(x)
|
|
|
|
/// Hyperbolic Secant
|
|
let sech (x : complex) = Trig.Sech(x)
|
|
|
|
/// Hyperbolic Cosecant
|
|
let csch (x : complex) = Trig.Csch(x)
|
|
|
|
|
|
/// Inverse Hyperbolic Sine
|
|
let asinh (x : complex) = Trig.Asinh(x)
|
|
|
|
/// Inverse Hyperbolic Cosine
|
|
let acosh (x : complex) = Trig.Acosh(x)
|
|
|
|
/// Inverse Hyperbolic Tangent
|
|
let atanh (x : complex) = Trig.Atanh(x)
|
|
|
|
/// Inverse Hyperbolic Cotangent
|
|
let acoth (x : complex) = Trig.Acoth(x)
|
|
|
|
/// Inverse Hyperbolic Secant
|
|
let asech (x : complex) = Trig.Asech(x)
|
|
|
|
/// Inverse Hyperbolic Cosecant
|
|
let acsch (x : complex) = Trig.Acsch(x)
|
|
|
|
|
|
//
|
|
[<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
|
|
module Complex32 =
|
|
/// Create a complex number using real and imaginary parts
|
|
let mkRect(a,b) = new Complex32(a,b)
|
|
|
|
/// Create a complex number using magnitude/phase polar coordinates
|
|
let mkPolar(a,b) = Complex32.FromPolarCoordinates(a,b)
|
|
|
|
/// A complex of magnitude 1 and the given phase and , i.e. cis x = mkPolar 1.0 x
|
|
let cis b = mkPolar(1.0f,b)
|
|
|
|
//
|
|
let private ofComplex (x : complex) =
|
|
Complex32 (float32 x.Real, float32 x.Imaginary)
|
|
|
|
|
|
/// The complex number 0+0i
|
|
let zero = Complex32.Zero
|
|
|
|
/// The complex number 1+0i
|
|
let one = Complex32.One
|
|
|
|
/// The complex number 0+1i
|
|
let onei = Complex32.ImaginaryOne
|
|
|
|
/// pi
|
|
let pi = mkRect (float32 Math.PI,0.0f)
|
|
|
|
|
|
/// The real part of a complex number
|
|
let realPart (c:complex32) = c.Real
|
|
|
|
/// The imaginary part of a complex number
|
|
let imagPart (c:complex32) = c.Imaginary
|
|
|
|
/// The polar-coordinate magnitude of a complex number
|
|
let magnitude (c:complex32) = c.Magnitude
|
|
|
|
/// The polar-coordinate phase of a complex number
|
|
let phase (c:complex32) = c.Phase
|
|
|
|
|
|
/// Unary negation of a complex number
|
|
let neg (a:complex32) = -a
|
|
|
|
/// The conjugate of a complex number, i.e. x-yi
|
|
let conjugate (c:complex32) = c.Conjugate()
|
|
|
|
|
|
/// Add two complex numbers
|
|
let add (a:complex32) (b:complex32) = a + b
|
|
|
|
/// Subtract one complex number from another
|
|
let sub (a:complex32) (b:complex32) = a - b
|
|
|
|
/// Multiply two complex numbers
|
|
let mul (a:complex32) (b:complex32) = a * b
|
|
|
|
/// Complex division of two complex numbers
|
|
let div (x:complex32) (y:complex32) = x / y
|
|
|
|
|
|
/// Multiply a scalar by a complex number
|
|
let smul (a:float32) (b:complex32) =
|
|
Complex32(a * b.Real, a * b.Imaginary)
|
|
|
|
/// Multiply a complex number by a scalar
|
|
let muls (a:complex32) (b:float32) =
|
|
Complex32(a.Real * b, a.Imaginary * b)
|
|
|
|
|
|
/// exp(x) = e^x
|
|
let exp (x:complex32) = Complex32.Exp(x)
|
|
|
|
/// ln(x) is natural log (base e)
|
|
let ln x = Complex32.Log(x)
|
|
|
|
/// log10(x) is common log (base 10)
|
|
let log10 x = Complex32.Log10(x)
|
|
|
|
/// log(base,x) is log with custom base
|
|
let log b x = Complex32.Log(x,b)
|
|
|
|
/// pow(power,x) is the complex power
|
|
let pow (power:complex32) x = Complex32.Pow(x,power)
|
|
|
|
/// pow(power,x) is the scalar power
|
|
let powf (power:float32) x = Complex32.Pow(x,power)
|
|
|
|
|
|
/// sqr(x) is the square (power 2)
|
|
let sqr (x:complex32) = x.Square()
|
|
|
|
/// sqrt(x) and 0 <= phase(x) < pi
|
|
let sqrt (x:complex32) =
|
|
// numerically more stable than Complex.Sqrt
|
|
x.SquareRoot()
|
|
|
|
|
|
(* Complex32 implementations are not yet available for some of the functions below.
|
|
TODO : Fix the functions below to use the Complex32 implementations once available. *)
|
|
|
|
/// Sine
|
|
let sin x = Complex32.Sin(x)
|
|
|
|
/// Cosine
|
|
let cos x = Complex32.Cos(x)
|
|
|
|
/// Tangent
|
|
let tan x = Complex32.Tan(x)
|
|
|
|
/// Cotangent
|
|
let cot (x:complex32) = ofComplex <| Trig.Cot(x.ToComplex())
|
|
|
|
/// Secant
|
|
let sec (x:complex32) = ofComplex <| Trig.Sec(x.ToComplex())
|
|
|
|
/// Cosecant
|
|
let csc (x:complex32) = ofComplex <| Trig.Csc(x.ToComplex())
|
|
|
|
|
|
/// Arc Sine
|
|
let asin (x:complex32) =
|
|
// numerically more stable than Complex.Asin
|
|
ofComplex <| Trig.Asin(x.ToComplex())
|
|
|
|
/// Arc Cosine
|
|
let acos (x:complex32) =
|
|
// numerically more stable than Complex.Acos
|
|
ofComplex <| Trig.Acos(x.ToComplex())
|
|
|
|
/// Arc Tangent
|
|
let atan x = Complex32.Atan(x)
|
|
|
|
/// Arc Cotangent
|
|
let acot (x:complex32) = ofComplex <| Trig.Acot(x.ToComplex())
|
|
|
|
/// Arc Secant
|
|
let asec (x:complex32) = ofComplex <| Trig.Asec(x.ToComplex())
|
|
|
|
/// Arc Cosecant
|
|
let acsc (x:complex32) = ofComplex <| Trig.Acsc(x.ToComplex())
|
|
|
|
|
|
/// Hyperbolic Sine
|
|
let sinh x = Complex32.Sinh(x)
|
|
|
|
/// Hyperbolic Cosine
|
|
let cosh x = Complex32.Cosh(x)
|
|
|
|
/// Hyperbolic Tangent
|
|
let tanh x = Complex32.Tanh(x)
|
|
|
|
/// Hyperbolic Cotangent
|
|
let coth (x:complex32) = ofComplex <| Trig.Coth(x.ToComplex())
|
|
|
|
/// Hyperbolic Secant
|
|
let sech (x:complex32) = ofComplex <| Trig.Sech(x.ToComplex())
|
|
|
|
/// Hyperbolic Cosecant
|
|
let csch (x:complex32) = ofComplex <| Trig.Csch(x.ToComplex())
|
|
|
|
|
|
/// Inverse Hyperbolic Sine
|
|
let asinh (x:complex32) = ofComplex <| Trig.Asinh(x.ToComplex())
|
|
|
|
/// Inverse Hyperbolic Cosine
|
|
let acosh (x:complex32) = ofComplex <| Trig.Acosh(x.ToComplex())
|
|
|
|
/// Inverse Hyperbolic Tangent
|
|
let atanh (x:complex32) = ofComplex <| Trig.Atanh(x.ToComplex())
|
|
|
|
/// Inverse Hyperbolic Cotangent
|
|
let acoth (x:complex32) = ofComplex <| Trig.Acoth(x.ToComplex())
|
|
|
|
/// Inverse Hyperbolic Secant
|
|
let asech (x:complex32) = ofComplex <| Trig.Asech(x.ToComplex())
|
|
|
|
/// Inverse Hyperbolic Cosecant
|
|
let acsch (x:complex32) = ofComplex <| Trig.Acsch(x.ToComplex())
|
|
|
|
|
|
//
|
|
[<AutoOpen>]
|
|
module ComplexExtensions =
|
|
/// Constructs a double precision complex number from both the real and imaginary part.
|
|
let complex x y =
|
|
Complex.mkRect (x,y)
|
|
|
|
/// Constructs a single precision complex number from both the real and imaginary part.
|
|
let complex32 x y =
|
|
Complex32.mkRect (x,y)
|
|
|
|
// The type of complex numbers stored as pairs of 64-bit floating point numbers in rectangular coordinates
|
|
type Complex with
|
|
/// The real part of a complex number
|
|
member x.r = x.Real
|
|
/// The imaginary part of a complex number
|
|
member x.i = x.Imaginary
|
|
|
|
/// Create a complex number x+ij using rectangular coordinates
|
|
static member Create(a,b) =
|
|
Complex.mkRect (a,b)
|
|
|
|
/// Create a complex number using magnitude/phase polar coordinates
|
|
static member CreatePolar(a,b) =
|
|
Complex.mkPolar (a,b)
|
|
|
|
/// The type of complex numbers stored as pairs of 32-bit floating point numbers in rectangular coordinates
|
|
type Complex32 with
|
|
/// The real part of a complex number
|
|
member x.r = x.Real
|
|
/// The imaginary part of a complex number
|
|
member x.i = x.Imaginary
|
|
|
|
/// Create a complex number x+ij using rectangular coordinates
|
|
static member Create(a,b) =
|
|
Complex32.mkRect (a,b)
|
|
|
|
/// Create a complex number using magnitude/phase polar coordinates
|
|
static member CreatePolar(a,b) =
|
|
Complex32.mkPolar (a,b)
|
|
|