ohsl 0.12.0

A collection of numerical routines and mathematical types for use in scientific computing.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use crate::complex::{Complex, Cmplx};
use crate::traits::One;
use crate::constant::{I, PI_2};

impl Complex::<f64> {
    ///Return the sin of a complex number z ( sin(z) )
    #[inline]
    pub fn sin(&self) -> Complex<f64> {
        Cmplx::new(self.real.sin() * self.imag.cosh(), self.real.cos() * self.imag.sinh())
    }

    ///Return the cos of a complex number z ( cos(z) )
    #[inline]
    pub fn cos(&self) -> Complex<f64> {
        Cmplx::new(self.real.cos() * self.imag.cosh(), -self.real.sin() * self.imag.sinh())
    }

    ///Return the tan of a complex number z ( tan(z) )
    #[inline]
    pub fn tan(&self) -> Complex<f64> {
        self.sin() / self.cos()
    }

    ///Return the sec of a complex number z ( sec(z) )
    #[inline]
    pub fn sec(&self) -> Complex<f64> {
        Complex::<f64>::one() / self.cos()
    }

    ///Return the csc of a complex number z ( csc(z) )
    #[inline]
    pub fn csc(&self) -> Complex<f64> {
        Complex::<f64>::one() / self.sin()
    }
    
    ///Return the cot of a complex number z ( cot(z) )
    #[inline]
    pub fn cot(&self) -> Complex<f64> {
        Complex::<f64>::one() / self.tan()
    }

    /// Return the inverse sin of a complex number z ( asin(z) )
    #[inline]
    pub fn asin(&self) -> Complex<f64> {
        let squared = self.clone() * self.clone();
        - I * ((Cmplx::one() - squared).sqrt() + I * self.clone()).ln()
    }

    /// Return the inverse cos of a complex number z ( acos(z) )
    #[inline]
    pub fn acos(&self) -> Complex<f64> {
        let squared = self.clone() * self.clone();
        I * ((Cmplx::one() - squared).sqrt() + I * self.clone()).ln() + PI_2
    }

    /// Return the inverse tan of a complex number z ( atan(z) )
    #[inline]
    pub fn atan(&self) -> Complex<f64> {
        let iz = I * self.clone();
        ( (Cmplx::one() - iz).ln() - (Cmplx::one() + iz).ln() ) * I * 0.5
    }

    /// Return the inverse sec of a complex number z ( asec(z) )
    #[inline]
    pub fn asec(&self) -> Complex<f64> {
        let inv = Cmplx::one() / self.clone();
        inv.acos()
    }

    /// Return the inverse csc of a complex number z ( acsc(z) )
    #[inline]
    pub fn acsc(&self) -> Complex<f64> {
        let inv = Cmplx::one() / self.clone();
        inv.asin()
    }

    /// Return the inverse cot of a complex number z ( acot(z) )
    #[inline]
    pub fn acot(&self) -> Complex<f64> {
        let inv = Cmplx::one() / self.clone();
        inv.atan()
    }
}