1#[inline(always)]
  2pub fn reim_add_ref(res: &mut [f64], a: &[f64], b: &[f64]) {
  3    #[cfg(debug_assertions)]
  4    {
  5        assert_eq!(a.len(), res.len());
  6        assert_eq!(b.len(), res.len());
  7    }
  8
  9    for i in 0..res.len() {
 10        res[i] = a[i] + b[i]
 11    }
 12}
 13
 14#[inline(always)]
 15pub fn reim_add_inplace_ref(res: &mut [f64], a: &[f64]) {
 16    #[cfg(debug_assertions)]
 17    {
 18        assert_eq!(a.len(), res.len());
 19    }
 20
 21    for i in 0..res.len() {
 22        res[i] += a[i]
 23    }
 24}
 25
 26#[inline(always)]
 27pub fn reim_sub_ref(res: &mut [f64], a: &[f64], b: &[f64]) {
 28    #[cfg(debug_assertions)]
 29    {
 30        assert_eq!(a.len(), res.len());
 31        assert_eq!(b.len(), res.len());
 32    }
 33
 34    for i in 0..res.len() {
 35        res[i] = a[i] - b[i]
 36    }
 37}
 38
 39#[inline(always)]
 40pub fn reim_sub_inplace_ref(res: &mut [f64], a: &[f64]) {
 41    #[cfg(debug_assertions)]
 42    {
 43        assert_eq!(a.len(), res.len());
 44    }
 45
 46    for i in 0..res.len() {
 47        res[i] -= a[i]
 48    }
 49}
 50
 51#[inline(always)]
 52pub fn reim_sub_negate_inplace_ref(res: &mut [f64], a: &[f64]) {
 53    #[cfg(debug_assertions)]
 54    {
 55        assert_eq!(a.len(), res.len());
 56    }
 57
 58    for i in 0..res.len() {
 59        res[i] = a[i] - res[i]
 60    }
 61}
 62
 63#[inline(always)]
 64pub fn reim_negate_ref(res: &mut [f64], a: &[f64]) {
 65    #[cfg(debug_assertions)]
 66    {
 67        assert_eq!(a.len(), res.len());
 68    }
 69
 70    for i in 0..res.len() {
 71        res[i] = -a[i]
 72    }
 73}
 74
 75#[inline(always)]
 76pub fn reim_negate_inplace_ref(res: &mut [f64]) {
 77    for ri in res {
 78        *ri = -*ri
 79    }
 80}
 81
 82#[inline(always)]
 83pub fn reim_addmul_ref(res: &mut [f64], a: &[f64], b: &[f64]) {
 84    #[cfg(debug_assertions)]
 85    {
 86        assert_eq!(a.len(), res.len());
 87        assert_eq!(b.len(), res.len());
 88    }
 89
 90    let m: usize = res.len() >> 1;
 91
 92    let (rr, ri) = res.split_at_mut(m);
 93    let (ar, ai) = a.split_at(m);
 94    let (br, bi) = b.split_at(m);
 95
 96    for i in 0..m {
 97        let _ar: f64 = ar[i];
 98        let _ai: f64 = ai[i];
 99        let _br: f64 = br[i];
100        let _bi: f64 = bi[i];
101        let _rr: f64 = _ar * _br - _ai * _bi;
102        let _ri: f64 = _ar * _bi + _ai * _br;
103        rr[i] += _rr;
104        ri[i] += _ri;
105    }
106}
107
108#[inline(always)]
109pub fn reim_mul_inplace_ref(res: &mut [f64], a: &[f64]) {
110    #[cfg(debug_assertions)]
111    {
112        assert_eq!(a.len(), res.len());
113    }
114
115    let m: usize = res.len() >> 1;
116
117    let (rr, ri) = res.split_at_mut(m);
118    let (ar, ai) = a.split_at(m);
119
120    for i in 0..m {
121        let _ar: f64 = ar[i];
122        let _ai: f64 = ai[i];
123        let _br: f64 = rr[i];
124        let _bi: f64 = ri[i];
125        let _rr: f64 = _ar * _br - _ai * _bi;
126        let _ri: f64 = _ar * _bi + _ai * _br;
127        rr[i] = _rr;
128        ri[i] = _ri;
129    }
130}
131
132#[inline(always)]
133pub fn reim_mul_ref(res: &mut [f64], a: &[f64], b: &[f64]) {
134    #[cfg(debug_assertions)]
135    {
136        assert_eq!(a.len(), res.len());
137        assert_eq!(b.len(), res.len());
138    }
139
140    let m: usize = res.len() >> 1;
141
142    let (rr, ri) = res.split_at_mut(m);
143    let (ar, ai) = a.split_at(m);
144    let (br, bi) = b.split_at(m);
145
146    for i in 0..m {
147        let _ar: f64 = ar[i];
148        let _ai: f64 = ai[i];
149        let _br: f64 = br[i];
150        let _bi: f64 = bi[i];
151        let _rr: f64 = _ar * _br - _ai * _bi;
152        let _ri: f64 = _ar * _bi + _ai * _br;
153        rr[i] = _rr;
154        ri[i] = _ri;
155    }
156}