1use crate::{
2 api::{
3 ScratchAvailable, ScratchFromBytes, ScratchOwnedAlloc, ScratchOwnedBorrow, TakeLike, TakeMatZnx, TakeScalarZnx,
4 TakeSlice, TakeSvpPPol, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, TakeVecZnxDftSlice, TakeVecZnxSlice, TakeVmpPMat,
5 },
6 layouts::{Backend, DataRef, MatZnx, ScalarZnx, Scratch, ScratchOwned, SvpPPol, VecZnx, VecZnxBig, VecZnxDft, VmpPMat},
7 oep::{
8 ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeLikeImpl, TakeMatZnxImpl,
9 TakeScalarZnxImpl, TakeSliceImpl, TakeSvpPPolImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxDftSliceImpl,
10 TakeVecZnxImpl, TakeVecZnxSliceImpl, TakeVmpPMatImpl,
11 },
12};
13
14impl<B> ScratchOwnedAlloc<B> for ScratchOwned<B>
15where
16 B: Backend + ScratchOwnedAllocImpl<B>,
17{
18 fn alloc(size: usize) -> Self {
19 B::scratch_owned_alloc_impl(size)
20 }
21}
22
23impl<B> ScratchOwnedBorrow<B> for ScratchOwned<B>
24where
25 B: Backend + ScratchOwnedBorrowImpl<B>,
26{
27 fn borrow(&mut self) -> &mut Scratch<B> {
28 B::scratch_owned_borrow_impl(self)
29 }
30}
31
32impl<B> ScratchFromBytes<B> for Scratch<B>
33where
34 B: Backend + ScratchFromBytesImpl<B>,
35{
36 fn from_bytes(data: &mut [u8]) -> &mut Scratch<B> {
37 B::scratch_from_bytes_impl(data)
38 }
39}
40
41impl<B> ScratchAvailable for Scratch<B>
42where
43 B: Backend + ScratchAvailableImpl<B>,
44{
45 fn available(&self) -> usize {
46 B::scratch_available_impl(self)
47 }
48}
49
50impl<B> TakeSlice for Scratch<B>
51where
52 B: Backend + TakeSliceImpl<B>,
53{
54 fn take_slice<T>(&mut self, len: usize) -> (&mut [T], &mut Self) {
55 B::take_slice_impl(self, len)
56 }
57}
58
59impl<B> TakeScalarZnx for Scratch<B>
60where
61 B: Backend + TakeScalarZnxImpl<B>,
62{
63 fn take_scalar_znx(&mut self, n: usize, cols: usize) -> (ScalarZnx<&mut [u8]>, &mut Self) {
64 B::take_scalar_znx_impl(self, n, cols)
65 }
66}
67
68impl<B> TakeSvpPPol<B> for Scratch<B>
69where
70 B: Backend + TakeSvpPPolImpl<B>,
71{
72 fn take_svp_ppol(&mut self, n: usize, cols: usize) -> (SvpPPol<&mut [u8], B>, &mut Self) {
73 B::take_svp_ppol_impl(self, n, cols)
74 }
75}
76
77impl<B> TakeVecZnx for Scratch<B>
78where
79 B: Backend + TakeVecZnxImpl<B>,
80{
81 fn take_vec_znx(&mut self, n: usize, cols: usize, size: usize) -> (VecZnx<&mut [u8]>, &mut Self) {
82 B::take_vec_znx_impl(self, n, cols, size)
83 }
84}
85
86impl<B> TakeVecZnxSlice for Scratch<B>
87where
88 B: Backend + TakeVecZnxSliceImpl<B>,
89{
90 fn take_vec_znx_slice(&mut self, len: usize, n: usize, cols: usize, size: usize) -> (Vec<VecZnx<&mut [u8]>>, &mut Self) {
91 B::take_vec_znx_slice_impl(self, len, n, cols, size)
92 }
93}
94
95impl<B> TakeVecZnxBig<B> for Scratch<B>
96where
97 B: Backend + TakeVecZnxBigImpl<B>,
98{
99 fn take_vec_znx_big(&mut self, n: usize, cols: usize, size: usize) -> (VecZnxBig<&mut [u8], B>, &mut Self) {
100 B::take_vec_znx_big_impl(self, n, cols, size)
101 }
102}
103
104impl<B> TakeVecZnxDft<B> for Scratch<B>
105where
106 B: Backend + TakeVecZnxDftImpl<B>,
107{
108 fn take_vec_znx_dft(&mut self, n: usize, cols: usize, size: usize) -> (VecZnxDft<&mut [u8], B>, &mut Self) {
109 B::take_vec_znx_dft_impl(self, n, cols, size)
110 }
111}
112
113impl<B> TakeVecZnxDftSlice<B> for Scratch<B>
114where
115 B: Backend + TakeVecZnxDftSliceImpl<B>,
116{
117 fn take_vec_znx_dft_slice(
118 &mut self,
119 len: usize,
120 n: usize,
121 cols: usize,
122 size: usize,
123 ) -> (Vec<VecZnxDft<&mut [u8], B>>, &mut Self) {
124 B::take_vec_znx_dft_slice_impl(self, len, n, cols, size)
125 }
126}
127
128impl<B> TakeVmpPMat<B> for Scratch<B>
129where
130 B: Backend + TakeVmpPMatImpl<B>,
131{
132 fn take_vmp_pmat(
133 &mut self,
134 n: usize,
135 rows: usize,
136 cols_in: usize,
137 cols_out: usize,
138 size: usize,
139 ) -> (VmpPMat<&mut [u8], B>, &mut Self) {
140 B::take_vmp_pmat_impl(self, n, rows, cols_in, cols_out, size)
141 }
142}
143
144impl<B> TakeMatZnx for Scratch<B>
145where
146 B: Backend + TakeMatZnxImpl<B>,
147{
148 fn take_mat_znx(
149 &mut self,
150 n: usize,
151 rows: usize,
152 cols_in: usize,
153 cols_out: usize,
154 size: usize,
155 ) -> (MatZnx<&mut [u8]>, &mut Self) {
156 B::take_mat_znx_impl(self, n, rows, cols_in, cols_out, size)
157 }
158}
159
160impl<'a, B: Backend, D> TakeLike<'a, B, ScalarZnx<D>> for Scratch<B>
161where
162 B: TakeLikeImpl<'a, B, ScalarZnx<D>, Output = ScalarZnx<&'a mut [u8]>>,
163 D: DataRef,
164{
165 type Output = ScalarZnx<&'a mut [u8]>;
166 fn take_like(&'a mut self, template: &ScalarZnx<D>) -> (Self::Output, &'a mut Self) {
167 B::take_like_impl(self, template)
168 }
169}
170
171impl<'a, B: Backend, D> TakeLike<'a, B, SvpPPol<D, B>> for Scratch<B>
172where
173 B: TakeLikeImpl<'a, B, SvpPPol<D, B>, Output = SvpPPol<&'a mut [u8], B>>,
174 D: DataRef,
175{
176 type Output = SvpPPol<&'a mut [u8], B>;
177 fn take_like(&'a mut self, template: &SvpPPol<D, B>) -> (Self::Output, &'a mut Self) {
178 B::take_like_impl(self, template)
179 }
180}
181
182impl<'a, B: Backend, D> TakeLike<'a, B, VecZnx<D>> for Scratch<B>
183where
184 B: TakeLikeImpl<'a, B, VecZnx<D>, Output = VecZnx<&'a mut [u8]>>,
185 D: DataRef,
186{
187 type Output = VecZnx<&'a mut [u8]>;
188 fn take_like(&'a mut self, template: &VecZnx<D>) -> (Self::Output, &'a mut Self) {
189 B::take_like_impl(self, template)
190 }
191}
192
193impl<'a, B: Backend, D> TakeLike<'a, B, VecZnxBig<D, B>> for Scratch<B>
194where
195 B: TakeLikeImpl<'a, B, VecZnxBig<D, B>, Output = VecZnxBig<&'a mut [u8], B>>,
196 D: DataRef,
197{
198 type Output = VecZnxBig<&'a mut [u8], B>;
199 fn take_like(&'a mut self, template: &VecZnxBig<D, B>) -> (Self::Output, &'a mut Self) {
200 B::take_like_impl(self, template)
201 }
202}
203
204impl<'a, B: Backend, D> TakeLike<'a, B, VecZnxDft<D, B>> for Scratch<B>
205where
206 B: TakeLikeImpl<'a, B, VecZnxDft<D, B>, Output = VecZnxDft<&'a mut [u8], B>>,
207 D: DataRef,
208{
209 type Output = VecZnxDft<&'a mut [u8], B>;
210 fn take_like(&'a mut self, template: &VecZnxDft<D, B>) -> (Self::Output, &'a mut Self) {
211 B::take_like_impl(self, template)
212 }
213}
214
215impl<'a, B: Backend, D> TakeLike<'a, B, MatZnx<D>> for Scratch<B>
216where
217 B: TakeLikeImpl<'a, B, MatZnx<D>, Output = MatZnx<&'a mut [u8]>>,
218 D: DataRef,
219{
220 type Output = MatZnx<&'a mut [u8]>;
221 fn take_like(&'a mut self, template: &MatZnx<D>) -> (Self::Output, &'a mut Self) {
222 B::take_like_impl(self, template)
223 }
224}
225
226impl<'a, B: Backend, D> TakeLike<'a, B, VmpPMat<D, B>> for Scratch<B>
227where
228 B: TakeLikeImpl<'a, B, VmpPMat<D, B>, Output = VmpPMat<&'a mut [u8], B>>,
229 D: DataRef,
230{
231 type Output = VmpPMat<&'a mut [u8], B>;
232 fn take_like(&'a mut self, template: &VmpPMat<D, B>) -> (Self::Output, &'a mut Self) {
233 B::take_like_impl(self, template)
234 }
235}