dashu-cmplx 0.5.0

A big arbitrary precision complex number library
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Complex addition and subtraction.
//!
//! Addition and subtraction are componentwise perfectly-rounded real additions/subtractions on each
//! part, forwarded through the shared [`impl_cbig_binop!`] macro (same pattern as `Mul` / `Div`).

use crate::cbig::CBig;
use crate::repr::{combine_parts, CfpResult, Context};
use core::ops::{Add, AddAssign, Sub, SubAssign};
use dashu_float::round::Round;
use dashu_int::Word;

impl<R: Round> Context<R> {
    /// Add two complex numbers under this context (context layer).
    ///
    /// Returns a [`CfpResult`] carrying each part's inexactness. Addition is componentwise, so each
    /// part is a single correctly-rounded real addition.
    pub fn add<const B: Word>(&self, z: &CBig<R, B>, w: &CBig<R, B>) -> CfpResult<R, B> {
        let re = self.float().add(z.re(), w.re())?;
        let im = self.float().add(z.im(), w.im())?;
        Ok(combine_parts(re, im))
    }

    /// Subtract two complex numbers under this context (context layer).
    ///
    /// Returns a [`CfpResult`] carrying each part's inexactness. Subtraction is componentwise, so each
    /// part is a single correctly-rounded real subtraction.
    pub fn sub<const B: Word>(&self, z: &CBig<R, B>, w: &CBig<R, B>) -> CfpResult<R, B> {
        let re = self.float().sub(z.re(), w.re())?;
        let im = self.float().sub(z.im(), w.im())?;
        Ok(combine_parts(re, im))
    }
}

// --- Add: all four ref/val combinations, plus Assign, via the shared macro ---
crate::helper_macros::impl_cbig_binop!(Add, add, AddAssign, add_assign);

// --- Sub: all four ref/val combinations, plus Assign, via the shared macro ---
crate::helper_macros::impl_cbig_binop!(Sub, sub, SubAssign, sub_assign);

#[cfg(test)]
mod tests {
    use super::*;
    use dashu_float::round::mode;

    type C = CBig<mode::HalfAway, 10>;

    #[test]
    fn add_componentwise() {
        let z = C::from_parts(3.into(), 4.into());
        let w = C::from_parts(1.into(), 2.into());
        let r = &z + &w;
        assert_eq!(r.re().significand(), &4.into());
        assert_eq!(r.im().significand(), &6.into());
    }

    #[test]
    fn add_all_ref_val_combinations() {
        let z = C::from_parts(1.into(), 2.into());
        let w = C::from_parts(3.into(), 4.into());
        // val + val, val + ref, ref + val, ref + ref
        assert_eq!((z.clone() + w.clone()).im().significand(), &6.into());
        assert_eq!((z.clone() + &w).im().significand(), &6.into());
        assert_eq!((&z + w.clone()).im().significand(), &6.into());
        assert_eq!((&z + &w).im().significand(), &6.into());
    }

    #[test]
    fn add_assign_val_and_ref() {
        let z = C::from_parts(1.into(), 2.into());
        let w = C::from_parts(3.into(), 4.into());

        let mut acc = z.clone();
        acc += w.clone();
        assert_eq!(acc.re().significand(), &4.into());
        assert_eq!(acc.im().significand(), &6.into());

        let mut acc = z.clone();
        acc += &w;
        assert_eq!(acc.re().significand(), &4.into());
    }

    #[test]
    fn sub_componentwise() {
        let z = C::from_parts(3.into(), 4.into());
        let w = C::from_parts(1.into(), 2.into());
        let r = &z - &w;
        assert_eq!(r.re().significand(), &2.into());
        assert_eq!(r.im().significand(), &2.into());
    }

    #[test]
    fn sub_all_ref_val_combinations() {
        let z = C::from_parts(5.into(), 6.into());
        let w = C::from_parts(2.into(), 1.into());
        assert_eq!((z.clone() - w.clone()).re().significand(), &3.into());
        assert_eq!((z.clone() - &w).re().significand(), &3.into());
        assert_eq!((&z - w.clone()).re().significand(), &3.into());
        assert_eq!((&z - &w).re().significand(), &3.into());
    }

    #[test]
    fn z_minus_z_is_zero() {
        let z = C::from_parts(7.into(), 9.into());
        let r = &z - &z;
        assert!(r.is_zero());
    }

    #[test]
    fn sub_assign_val_and_ref() {
        let z = C::from_parts(5.into(), 6.into());
        let w = C::from_parts(2.into(), 1.into());

        let mut acc = z.clone();
        acc -= w.clone();
        assert_eq!(acc.re().significand(), &3.into());
        assert_eq!(acc.im().significand(), &5.into());

        let mut acc = z.clone();
        acc -= &w;
        assert_eq!(acc.re().significand(), &3.into());
    }
}