1use crate::ffi::{self, blas_int, c_char};
2use crate::util::*;
3use derive_builder::Builder;
4use ndarray::prelude::*;
5
6pub trait HPR2Num: BLASFloat {
9 unsafe fn hpr2(
10 uplo: *const c_char,
11 n: *const blas_int,
12 alpha: *const Self,
13 x: *const Self,
14 incx: *const blas_int,
15 y: *const Self,
16 incy: *const blas_int,
17 ap: *mut Self,
18 );
19}
20
21macro_rules! impl_func {
22 ($type: ty, $func: ident) => {
23 impl HPR2Num for $type {
24 unsafe fn hpr2(
25 uplo: *const c_char,
26 n: *const blas_int,
27 alpha: *const Self,
28 x: *const Self,
29 incx: *const blas_int,
30 y: *const Self,
31 incy: *const blas_int,
32 ap: *mut Self,
33 ) {
34 ffi::$func(uplo, n, alpha, x, incx, y, incy, ap);
35 }
36 }
37 };
38}
39
40impl_func!(f32, sspr2_);
41impl_func!(f64, dspr2_);
42impl_func!(c32, chpr2_);
43impl_func!(c64, zhpr2_);
44
45pub struct HPR2_Driver<'x, 'y, 'a, F>
50where
51 F: HPR2Num,
52{
53 uplo: c_char,
54 n: blas_int,
55 alpha: F,
56 x: ArrayView1<'x, F>,
57 incx: blas_int,
58 y: ArrayView1<'y, F>,
59 incy: blas_int,
60 ap: ArrayOut1<'a, F>,
61}
62
63impl<'x, 'y, 'a, F> BLASDriver<'a, F, Ix1> for HPR2_Driver<'x, 'y, 'a, F>
64where
65 F: HPR2Num,
66{
67 fn run_blas(self) -> Result<ArrayOut1<'a, F>, BLASError> {
68 let Self { uplo, n, alpha, x, incx, y, incy, mut ap } = self;
69 let x_ptr = x.as_ptr();
70 let y_ptr = y.as_ptr();
71 let ap_ptr = ap.get_data_mut_ptr();
72
73 if n == 0 {
76 return Ok(ap.clone_to_view_mut());
77 }
78
79 unsafe {
80 F::hpr2(&uplo, &n, &alpha, x_ptr, &incx, y_ptr, &incy, ap_ptr);
81 }
82 return Ok(ap.clone_to_view_mut());
83 }
84}
85
86#[derive(Builder)]
91#[builder(pattern = "owned", build_fn(error = "BLASError"), no_std)]
92pub struct HPR2_<'x, 'y, 'a, F>
93where
94 F: HPR2Num,
95{
96 pub x: ArrayView1<'x, F>,
97 pub y: ArrayView1<'y, F>,
98
99 #[builder(setter(into, strip_option), default = "None")]
100 pub ap: Option<ArrayViewMut1<'a, F>>,
101 #[builder(setter(into), default = "F::one()")]
102 pub alpha: F,
103 #[builder(setter(into), default = "BLASUpper")]
104 pub uplo: BLASUpLo,
105 #[builder(setter(into, strip_option), default = "None")]
106 pub layout: Option<BLASLayout>,
107}
108
109impl<'x, 'y, 'a, F> BLASBuilder_<'a, F, Ix1> for HPR2_<'x, 'y, 'a, F>
110where
111 F: HPR2Num,
112{
113 fn driver(self) -> Result<HPR2_Driver<'x, 'y, 'a, F>, BLASError> {
114 let Self { x, y, ap, alpha, uplo, layout, .. } = self;
115
116 let incx = x.stride_of(Axis(0));
118 let incy = y.stride_of(Axis(0));
119 let n = x.len_of(Axis(0));
120
121 assert_eq!(layout, Some(BLASColMajor));
123
124 blas_assert_eq!(y.len_of(Axis(0)), n, InvalidDim)?;
126
127 let ap = match ap {
129 Some(ap) => {
130 blas_assert_eq!(ap.len_of(Axis(0)), n * (n + 1) / 2, InvalidDim)?;
131 if ap.is_standard_layout() {
132 ArrayOut1::ViewMut(ap)
133 } else {
134 let ap_buffer = ap.view().to_seq_layout()?.into_owned();
135 ArrayOut1::ToBeCloned(ap, ap_buffer)
136 }
137 },
138 None => ArrayOut1::Owned(Array1::zeros(n * (n + 1) / 2)),
139 };
140
141 let driver = HPR2_Driver {
143 uplo: uplo.try_into()?,
144 n: n.try_into()?,
145 alpha,
146 x,
147 incx: incx.try_into()?,
148 y,
149 incy: incy.try_into()?,
150 ap,
151 };
152 return Ok(driver);
153 }
154}
155
156pub type HPR2<'x, 'y, 'a, F> = HPR2_Builder<'x, 'y, 'a, F>;
161pub type SSPR2<'x, 'y, 'a> = HPR2<'x, 'y, 'a, f32>;
162pub type DSPR2<'x, 'y, 'a> = HPR2<'x, 'y, 'a, f64>;
163pub type CHPR2<'x, 'y, 'a> = HPR2<'x, 'y, 'a, c32>;
164pub type ZHPR2<'x, 'y, 'a> = HPR2<'x, 'y, 'a, c64>;
165
166impl<'x, 'y, 'a, F> BLASBuilder<'a, F, Ix1> for HPR2_Builder<'x, 'y, 'a, F>
167where
168 F: HPR2Num,
169{
170 fn run(self) -> Result<ArrayOut1<'a, F>, BLASError> {
171 let obj = self.build()?;
173
174 if obj.layout == Some(BLASColMajor) {
175 return obj.driver()?.run_blas();
177 } else {
178 let uplo = obj.uplo.flip()?;
180 if F::is_complex() {
181 let x = obj.x.mapv(F::conj);
182 let y = obj.y.mapv(F::conj);
183 let obj = HPR2_ { y: x.view(), x: y.view(), uplo, layout: Some(BLASColMajor), ..obj };
184 return obj.driver()?.run_blas();
185 } else {
186 let obj = HPR2_ { uplo, x: obj.y, y: obj.x, layout: Some(BLASColMajor), ..obj };
187 return obj.driver()?.run_blas();
188 };
189 }
190 }
191}
192
193