1use std::marker::PhantomData;
  2
  3use crate::ffi::vec_znx_dft;
  4use crate::znx_base::ZnxInfos;
  5use crate::{Backend, DataView, DataViewMut, FFT64, Module, ZnxSliceSize, ZnxView, alloc_aligned};
  6
  7pub struct VecZnxDft<D, B: Backend> {
  8    data: D,
  9    n: usize,
 10    cols: usize,
 11    size: usize,
 12    _phantom: PhantomData<B>,
 13}
 14
 15impl<D, B: Backend> ZnxInfos for VecZnxDft<D, B> {
 16    fn cols(&self) -> usize {
 17        self.cols
 18    }
 19
 20    fn rows(&self) -> usize {
 21        1
 22    }
 23
 24    fn n(&self) -> usize {
 25        self.n
 26    }
 27
 28    fn size(&self) -> usize {
 29        self.size
 30    }
 31}
 32
 33impl<D> ZnxSliceSize for VecZnxDft<D, FFT64> {
 34    fn sl(&self) -> usize {
 35        self.n() * self.cols()
 36    }
 37}
 38
 39impl<D, B: Backend> DataView for VecZnxDft<D, B> {
 40    type D = D;
 41    fn data(&self) -> &Self::D {
 42        &self.data
 43    }
 44}
 45
 46impl<D, B: Backend> DataViewMut for VecZnxDft<D, B> {
 47    fn data_mut(&mut self) -> &mut Self::D {
 48        &mut self.data
 49    }
 50}
 51
 52impl<D: AsRef<[u8]>> ZnxView for VecZnxDft<D, FFT64> {
 53    type Scalar = f64;
 54}
 55
 56pub(crate) fn bytes_of_vec_znx_dft<B: Backend>(module: &Module<B>, cols: usize, size: usize) -> usize {
 57    unsafe { vec_znx_dft::bytes_of_vec_znx_dft(module.ptr, size as u64) as usize * cols }
 58}
 59
 60impl<D: From<Vec<u8>>, B: Backend> VecZnxDft<D, B> {
 61    pub(crate) fn new(module: &Module<B>, cols: usize, size: usize) -> Self {
 62        let data = alloc_aligned::<u8>(bytes_of_vec_znx_dft(module, cols, size));
 63        Self {
 64            data: data.into(),
 65            n: module.n(),
 66            cols,
 67            size,
 68            _phantom: PhantomData,
 69        }
 70    }
 71
 72    pub(crate) fn new_from_bytes(module: &Module<B>, cols: usize, size: usize, bytes: impl Into<Vec<u8>>) -> Self {
 73        let data: Vec<u8> = bytes.into();
 74        assert!(data.len() == bytes_of_vec_znx_dft(module, cols, size));
 75        Self {
 76            data: data.into(),
 77            n: module.n(),
 78            cols,
 79            size,
 80            _phantom: PhantomData,
 81        }
 82    }
 83}
 84
 85pub type VecZnxDftOwned<B> = VecZnxDft<Vec<u8>, B>;
 86
 87impl<D, B: Backend> VecZnxDft<D, B> {
 88    pub(crate) fn from_data(data: D, n: usize, cols: usize, size: usize) -> Self {
 89        Self {
 90            data,
 91            n,
 92            cols,
 93            size,
 94            _phantom: PhantomData,
 95        }
 96    }
 97}
 98
 99pub trait VecZnxDftToRef<B: Backend> {
100    fn to_ref(&self) -> VecZnxDft<&[u8], B>;
101}
102
103pub trait VecZnxDftToMut<B: Backend> {
104    fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B>;
105}
106
107impl<B: Backend> VecZnxDftToMut<B> for VecZnxDft<Vec<u8>, B> {
108    fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B> {
109        VecZnxDft {
110            data: self.data.as_mut_slice(),
111            n: self.n,
112            cols: self.cols,
113            size: self.size,
114            _phantom: PhantomData,
115        }
116    }
117}
118
119impl<B: Backend> VecZnxDftToRef<B> for VecZnxDft<Vec<u8>, B> {
120    fn to_ref(&self) -> VecZnxDft<&[u8], B> {
121        VecZnxDft {
122            data: self.data.as_slice(),
123            n: self.n,
124            cols: self.cols,
125            size: self.size,
126            _phantom: PhantomData,
127        }
128    }
129}
130
131impl<B: Backend> VecZnxDftToMut<B> for VecZnxDft<&mut [u8], B> {
132    fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B> {
133        VecZnxDft {
134            data: self.data,
135            n: self.n,
136            cols: self.cols,
137            size: self.size,
138            _phantom: PhantomData,
139        }
140    }
141}
142
143impl<B: Backend> VecZnxDftToRef<B> for VecZnxDft<&mut [u8], B> {
144    fn to_ref(&self) -> VecZnxDft<&[u8], B> {
145        VecZnxDft {
146            data: self.data,
147            n: self.n,
148            cols: self.cols,
149            size: self.size,
150            _phantom: PhantomData,
151        }
152    }
153}
154
155impl<B: Backend> VecZnxDftToRef<B> for VecZnxDft<&[u8], B> {
156    fn to_ref(&self) -> VecZnxDft<&[u8], B> {
157        VecZnxDft {
158            data: self.data,
159            n: self.n,
160            cols: self.cols,
161            size: self.size,
162            _phantom: PhantomData,
163        }
164    }
165}