basic_dsp_vector/vector_types/
vec_impl_and_indexers.rs

1//! This module defines the basic vector trait and indexers.
2use super::meta::Complex as ComplexSpace;
3use super::meta::Real as RealSpace;
4use super::{
5    Buffer, BufferBorrow, ComplexNumberSpace, DataDomain, Domain, DspVec, ErrorReason, NumberSpace,
6    ToSlice, ToSliceMut, TypeMetaData, VoidResult,
7};
8use crate::multicore_support::MultiCoreSettings;
9use crate::numbers::*;
10use crate::{array_to_complex, array_to_complex_mut};
11use std::ops::*;
12
13/// Like [`std::ops::Index`](https://doc.rust-lang.org/std/ops/trait.Index.html)
14/// but with a different method name so that it can be used to implement an additional range
15/// accessor for float data.
16pub trait FloatIndex<Idx>
17where
18    Idx: Sized,
19{
20    type Output: ?Sized;
21    /// The method for float indexing. If the vector is real valued then this function just returns the values
22    // in the vector. If the vector is compled valued then will returned real and imaginary values interleaved (all
23    // values at even indexes are the real parts, while all values at odd indexes are imag parts).
24    fn data(&self, index: Idx) -> &Self::Output;
25}
26
27/// Like [`std::ops::IndexMut`](https://doc.rust-lang.org/std/ops/trait.IndexMut.html)
28/// but with a different method name so that it can be used to implement a additional range
29/// accessor for float data.
30pub trait FloatIndexMut<Idx>: FloatIndex<Idx>
31where
32    Idx: Sized,
33{
34    /// The method for real indexing
35    fn data_mut(&mut self, index: Idx) -> &mut Self::Output;
36}
37
38/// Like [`std::ops::Index`](https://doc.rust-lang.org/std/ops/trait.Index.html)
39/// but with a different method name so that it can be used to implement an additional range
40/// accessor for complex data.
41///
42/// Note if indexers will return an empty array in case the vector isn't complex.
43pub trait ComplexIndex<Idx>
44where
45    Idx: Sized,
46{
47    type Output: ?Sized;
48    /// The method for complex indexing
49    fn datac(&self, index: Idx) -> &Self::Output;
50}
51
52/// Like [`std::ops::IndexMut`](https://doc.rust-lang.org/std/ops/trait.IndexMut.html)
53/// but with a different method name so that it can be used to implement a additional range
54/// accessor for complex data.
55///
56/// Note if indexers will return an empty array in case the vector isn't complex.
57pub trait ComplexIndexMut<Idx>: ComplexIndex<Idx>
58where
59    Idx: Sized,
60{
61    /// The method for complex indexing
62    fn datac_mut(&mut self, index: Idx) -> &mut Self::Output;
63}
64
65/// A trait which provides information about number space and domain.
66pub trait MetaData {
67    /// The domain in which the data vector resides. Basically specifies the x-axis and the
68    /// type of operations which are valid on this vector.
69    ///
70    /// The domain can be changed using the `RededicateOps` trait.
71    fn domain(&self) -> DataDomain;
72
73    /// Indicates whether the vector contains complex data. This also specifies the type
74    /// of operations which are valid on this vector.
75    ///
76    /// The number space can be changed using the `RededicateOps` trait.
77    fn is_complex(&self) -> bool;
78}
79
80/// Operations to resize a data type.
81pub trait ResizeOps {
82    /// Changes `self.len()`.
83    /// If `self.is_complex()` is true then `len` must be an even number.
84    /// `len > self.alloc_len()` is only possible if the underlying storage supports resizing.
85    fn resize(&mut self, len: usize) -> VoidResult;
86}
87
88/// Operations to resize a data type.
89pub trait ResizeBufferedOps<S: ToSliceMut<T>, T: RealNumber> {
90    /// Changes `self.len()`.
91    /// If `self.is_complex()` is true then `len` must be an even number.
92    /// `len > self.alloc_len()` is only possible if the underlying storage or the buffer
93    /// supports resizing.
94    fn resize_b<B>(&mut self, buffer: &mut B, len: usize) -> VoidResult
95    where
96        B: for<'a> Buffer<'a, S, T>;
97}
98
99/// A trait for vector types.
100pub trait Vector<T>:
101    MetaData
102    + ResizeOps
103    + FloatIndex<RangeFull, Output = [T]>
104    + FloatIndex<Range<usize>>
105    + FloatIndex<RangeFrom<usize>, Output = [T]>
106    + FloatIndex<RangeTo<usize>>
107    + FloatIndex<usize>
108where
109    T: RealNumber,
110{
111    /// The x-axis delta. If `domain` is time domain then `delta` is in `[s]`,
112    /// in frequency domain `delta` is in `[Hz]`.
113    fn delta(&self) -> T;
114
115    /// Sets the x-axis delta. If `domain` is time domain then `delta` is in `[s]`,
116    /// in frequency domain `delta` is in `[Hz]`.
117    fn set_delta(&mut self, delta: T);
118
119    /// The number of valid elements in the vector. This can be changed
120    /// with the `Resize` trait.
121    fn len(&self) -> usize;
122
123    /// Indicates whether or not the vector is empty.
124    fn is_empty(&self) -> bool;
125
126    /// The number of valid points. If the vector is complex then every valid
127    /// point consists of two floating point numbers,
128    /// while for real vectors every point only consists of one floating point number.
129    fn points(&self) -> usize;
130
131    /// Gets the multi core settings which determine how the
132    /// work is split between several cores if the amount of data
133    /// gets larger.
134    fn get_multicore_settings(&self) -> &MultiCoreSettings;
135
136    /// Sets the multi core settings which determine how the
137    /// work is split between several cores if the amount of data
138    /// gets larger.
139    fn set_multicore_settings(&mut self, settings: MultiCoreSettings);
140
141    /// Gets the number of allocated elements in the underlying vector.
142    /// The allocated length may be larger than the length of valid points.
143    /// In most cases you likely want to have `len`or `points` instead.
144    fn alloc_len(&self) -> usize;
145}
146
147/// Gets the meta data of a type. This can be used to create a new type with the same
148/// meta data.
149/// # Example
150///
151/// ```
152/// use basic_dsp_vector::*;
153/// let vector = vec!(1.0, 2.0, 3.0, 4.0, 5.0, 6.0).to_real_time_vec();
154/// let meta_data = vector.get_meta_data();
155/// let slice = &vector[0..2];
156/// let slice = slice.to_dsp_vec(&meta_data);
157/// assert_eq!(false, slice.is_complex());
158/// ```
159pub trait GetMetaData<T, N, D>
160where
161    T: RealNumber,
162    N: NumberSpace,
163    D: Domain,
164{
165    /// Gets a copy of the vector meta data. This can be used to create
166    /// new types with the same meta data.
167    fn get_meta_data(&self) -> TypeMetaData<T, N, D>;
168}
169
170impl<S, T, N, D> MetaData for DspVec<S, T, N, D>
171where
172    S: ToSlice<T>,
173    T: RealNumber,
174    N: NumberSpace,
175    D: Domain,
176{
177    fn domain(&self) -> DataDomain {
178        self.domain.domain()
179    }
180
181    fn is_complex(&self) -> bool {
182        self.number_space.is_complex()
183    }
184}
185
186impl<T, N, D> MetaData for TypeMetaData<T, N, D>
187where
188    T: RealNumber,
189    N: NumberSpace,
190    D: Domain,
191{
192    fn domain(&self) -> DataDomain {
193        self.domain.domain()
194    }
195
196    fn is_complex(&self) -> bool {
197        self.number_space.is_complex()
198    }
199}
200
201impl<S, T, N, D> ResizeOps for DspVec<S, T, N, D>
202where
203    S: ToSlice<T>,
204    T: RealNumber,
205    N: NumberSpace,
206    D: Domain,
207{
208    fn resize(&mut self, len: usize) -> VoidResult {
209        if self.is_complex() && len % 2 != 0 {
210            return Err(ErrorReason::InputMustHaveAnEvenLength);
211        }
212
213        if len > self.alloc_len() {
214            self.data.try_resize(len)?;
215        }
216
217        self.valid_len = len;
218
219        Ok(())
220    }
221}
222
223impl<S, T, N, D> ResizeBufferedOps<S, T> for DspVec<S, T, N, D>
224where
225    S: ToSliceMut<T>,
226    T: RealNumber,
227    N: NumberSpace,
228    D: Domain,
229{
230    fn resize_b<B>(&mut self, buffer: &mut B, len: usize) -> VoidResult
231    where
232        B: for<'a> Buffer<'a, S, T>,
233    {
234        if self.is_complex() && len % 2 != 0 {
235            return Err(ErrorReason::InputMustHaveAnEvenLength);
236        }
237        let res = self.resize(len);
238        match res {
239            Ok(_) => Ok(()),
240            Err(_) => {
241                let orig_len = self.len();
242                let mut temp = buffer.borrow(len);
243                temp.to_slice_mut()[0..orig_len].clone_from_slice(self.data(..));
244                temp.trade(&mut self.data);
245                self.valid_len = len;
246                Ok(())
247            }
248        }
249    }
250}
251
252impl<S, T, N, D> Vector<T> for DspVec<S, T, N, D>
253where
254    S: ToSlice<T>,
255    T: RealNumber,
256    N: NumberSpace,
257    D: Domain,
258{
259    fn delta(&self) -> T {
260        self.delta
261    }
262
263    fn set_delta(&mut self, delta: T) {
264        self.delta = delta;
265    }
266
267    fn len(&self) -> usize {
268        self.valid_len
269    }
270
271    fn is_empty(&self) -> bool {
272        self.valid_len == 0
273    }
274
275    fn points(&self) -> usize {
276        self.valid_len / if self.is_complex() { 2 } else { 1 }
277    }
278
279    fn get_multicore_settings(&self) -> &MultiCoreSettings {
280        &self.multicore_settings
281    }
282
283    fn set_multicore_settings(&mut self, settings: MultiCoreSettings) {
284        self.multicore_settings = settings;
285    }
286
287    fn alloc_len(&self) -> usize {
288        self.data.len()
289    }
290}
291
292impl<S, T, N, D> GetMetaData<T, N, D> for DspVec<S, T, N, D>
293where
294    S: ToSlice<T>,
295    T: RealNumber,
296    N: NumberSpace,
297    D: Domain,
298{
299    fn get_meta_data(&self) -> TypeMetaData<T, N, D> {
300        TypeMetaData {
301            number_space: self.number_space.clone(),
302            domain: self.domain.clone(),
303            delta: self.delta,
304            multicore_settings: self.multicore_settings,
305        }
306    }
307}
308
309impl<S, T, N, D> FloatIndex<usize> for DspVec<S, T, N, D>
310where
311    S: ToSlice<T>,
312    T: RealNumber,
313    N: NumberSpace,
314    D: Domain,
315{
316    type Output = T;
317
318    fn data(&self, index: usize) -> &T {
319        let len = self.valid_len;
320        let slice = self.data.to_slice();
321        let slice = &slice[0..len];
322        &slice[index]
323    }
324}
325
326impl<S, T, N, D> FloatIndexMut<usize> for DspVec<S, T, N, D>
327where
328    S: ToSliceMut<T>,
329    T: RealNumber,
330    N: NumberSpace,
331    D: Domain,
332{
333    fn data_mut(&mut self, index: usize) -> &mut T {
334        let len = self.valid_len;
335        let slice = self.data.to_slice_mut();
336        let slice = &mut slice[0..len];
337        &mut slice[index]
338    }
339}
340
341impl<S, T, N, D> FloatIndex<RangeFull> for DspVec<S, T, N, D>
342where
343    S: ToSlice<T>,
344    T: RealNumber,
345    N: NumberSpace,
346    D: Domain,
347{
348    type Output = [T];
349
350    fn data(&self, _index: RangeFull) -> &[T] {
351        let len = self.valid_len;
352        let slice = self.data.to_slice();
353        &slice[0..len]
354    }
355}
356
357impl<S, T, N, D> FloatIndexMut<RangeFull> for DspVec<S, T, N, D>
358where
359    S: ToSliceMut<T>,
360    T: RealNumber,
361    N: NumberSpace,
362    D: Domain,
363{
364    fn data_mut(&mut self, _index: RangeFull) -> &mut [T] {
365        let len = self.valid_len;
366        let slice = self.data.to_slice_mut();
367        &mut slice[0..len]
368    }
369}
370
371impl<S, T, N, D> FloatIndex<RangeFrom<usize>> for DspVec<S, T, N, D>
372where
373    S: ToSlice<T>,
374    T: RealNumber,
375    N: NumberSpace,
376    D: Domain,
377{
378    type Output = [T];
379
380    fn data(&self, index: RangeFrom<usize>) -> &[T] {
381        let len = self.valid_len;
382        let slice = self.data.to_slice();
383        let slice = &slice[0..len];
384        &slice[index]
385    }
386}
387
388impl<S, T, N, D> FloatIndexMut<RangeFrom<usize>> for DspVec<S, T, N, D>
389where
390    S: ToSliceMut<T>,
391    T: RealNumber,
392    N: NumberSpace,
393    D: Domain,
394{
395    fn data_mut(&mut self, index: RangeFrom<usize>) -> &mut [T] {
396        let len = self.valid_len;
397        let slice = self.data.to_slice_mut();
398        let slice = &mut slice[0..len];
399        &mut slice[index]
400    }
401}
402
403impl<S, T, N, D> FloatIndex<RangeTo<usize>> for DspVec<S, T, N, D>
404where
405    S: ToSlice<T>,
406    T: RealNumber,
407    N: NumberSpace,
408    D: Domain,
409{
410    type Output = [T];
411
412    fn data(&self, index: RangeTo<usize>) -> &[T] {
413        let len = self.valid_len;
414        let slice = self.data.to_slice();
415        let slice = &slice[0..len];
416        &slice[index]
417    }
418}
419
420impl<S, T, N, D> FloatIndexMut<RangeTo<usize>> for DspVec<S, T, N, D>
421where
422    S: ToSliceMut<T>,
423    T: RealNumber,
424    N: NumberSpace,
425    D: Domain,
426{
427    fn data_mut(&mut self, index: RangeTo<usize>) -> &mut [T] {
428        let len = self.valid_len;
429        let slice = self.data.to_slice_mut();
430        let slice = &mut slice[0..len];
431        &mut slice[index]
432    }
433}
434
435impl<S, T, N, D> FloatIndex<Range<usize>> for DspVec<S, T, N, D>
436where
437    S: ToSlice<T>,
438    T: RealNumber,
439    N: NumberSpace,
440    D: Domain,
441{
442    type Output = [T];
443
444    fn data(&self, index: Range<usize>) -> &[T] {
445        let len = self.valid_len;
446        let slice = self.data.to_slice();
447        let slice = &slice[0..len];
448        &slice[index]
449    }
450}
451
452impl<S, T, N, D> FloatIndexMut<Range<usize>> for DspVec<S, T, N, D>
453where
454    S: ToSliceMut<T>,
455    T: RealNumber,
456    N: NumberSpace,
457    D: Domain,
458{
459    fn data_mut(&mut self, index: Range<usize>) -> &mut [T] {
460        let len = self.valid_len;
461        let slice = self.data.to_slice_mut();
462        let slice = &mut slice[0..len];
463        &mut slice[index]
464    }
465}
466
467impl<S, T, N, D> ComplexIndex<usize> for DspVec<S, T, N, D>
468where
469    S: ToSlice<T>,
470    T: RealNumber,
471    N: ComplexNumberSpace,
472    D: Domain,
473{
474    type Output = Complex<T>;
475
476    fn datac(&self, index: usize) -> &Complex<T> {
477        let len = self.valid_len;
478        let slice = self.data.to_slice();
479        let slice = array_to_complex(&slice[0..len]);
480        &slice[index]
481    }
482}
483
484impl<S, T, N, D> ComplexIndexMut<usize> for DspVec<S, T, N, D>
485where
486    S: ToSliceMut<T>,
487    T: RealNumber,
488    N: ComplexNumberSpace,
489    D: Domain,
490{
491    fn datac_mut(&mut self, index: usize) -> &mut Complex<T> {
492        let len = self.valid_len;
493        let slice = self.data.to_slice_mut();
494        let slice = array_to_complex_mut(&mut slice[0..len]);
495        &mut slice[index]
496    }
497}
498
499impl<S, T, N, D> ComplexIndex<RangeFull> for DspVec<S, T, N, D>
500where
501    S: ToSlice<T>,
502    T: RealNumber,
503    N: ComplexNumberSpace,
504    D: Domain,
505{
506    type Output = [Complex<T>];
507
508    fn datac(&self, _index: RangeFull) -> &[Complex<T>] {
509        let len = self.valid_len;
510        let slice = self.data.to_slice();
511        array_to_complex(&slice[0..len])
512    }
513}
514
515impl<S, T, N, D> ComplexIndexMut<RangeFull> for DspVec<S, T, N, D>
516where
517    S: ToSliceMut<T>,
518    T: RealNumber,
519    N: ComplexNumberSpace,
520    D: Domain,
521{
522    fn datac_mut(&mut self, _index: RangeFull) -> &mut [Complex<T>] {
523        let len = self.valid_len;
524        let slice = self.data.to_slice_mut();
525        array_to_complex_mut(&mut slice[0..len])
526    }
527}
528
529impl<S, T, N, D> ComplexIndex<RangeFrom<usize>> for DspVec<S, T, N, D>
530where
531    S: ToSlice<T>,
532    T: RealNumber,
533    N: ComplexNumberSpace,
534    D: Domain,
535{
536    type Output = [Complex<T>];
537
538    fn datac(&self, index: RangeFrom<usize>) -> &[Complex<T>] {
539        let len = self.valid_len;
540        let slice = self.data.to_slice();
541        let slice = array_to_complex(&slice[0..len]);
542        &slice[index]
543    }
544}
545
546impl<S, T, N, D> ComplexIndexMut<RangeFrom<usize>> for DspVec<S, T, N, D>
547where
548    S: ToSliceMut<T>,
549    T: RealNumber,
550    N: ComplexNumberSpace,
551    D: Domain,
552{
553    fn datac_mut(&mut self, index: RangeFrom<usize>) -> &mut [Complex<T>] {
554        let len = self.valid_len;
555        let slice = self.data.to_slice_mut();
556        let slice = array_to_complex_mut(&mut slice[0..len]);
557        &mut slice[index]
558    }
559}
560
561impl<S, T, N, D> ComplexIndex<RangeTo<usize>> for DspVec<S, T, N, D>
562where
563    S: ToSlice<T>,
564    T: RealNumber,
565    N: ComplexNumberSpace,
566    D: Domain,
567{
568    type Output = [Complex<T>];
569
570    fn datac(&self, index: RangeTo<usize>) -> &[Complex<T>] {
571        let len = self.valid_len;
572        let slice = self.data.to_slice();
573        let slice = array_to_complex(&slice[0..len]);
574        &slice[index]
575    }
576}
577
578impl<S, T, N, D> ComplexIndexMut<RangeTo<usize>> for DspVec<S, T, N, D>
579where
580    S: ToSliceMut<T>,
581    T: RealNumber,
582    N: ComplexNumberSpace,
583    D: Domain,
584{
585    fn datac_mut(&mut self, index: RangeTo<usize>) -> &mut [Complex<T>] {
586        let len = self.valid_len;
587        let slice = self.data.to_slice_mut();
588        let slice = array_to_complex_mut(&mut slice[0..len]);
589        &mut slice[index]
590    }
591}
592
593impl<S, T, N, D> ComplexIndex<Range<usize>> for DspVec<S, T, N, D>
594where
595    S: ToSlice<T>,
596    T: RealNumber,
597    N: ComplexNumberSpace,
598    D: Domain,
599{
600    type Output = [Complex<T>];
601
602    fn datac(&self, index: Range<usize>) -> &[Complex<T>] {
603        let len = self.valid_len;
604        let slice = self.data.to_slice();
605        let slice = array_to_complex(&slice[0..len]);
606        &slice[index]
607    }
608}
609
610impl<S, T, N, D> ComplexIndexMut<Range<usize>> for DspVec<S, T, N, D>
611where
612    S: ToSliceMut<T>,
613    T: RealNumber,
614    N: ComplexNumberSpace,
615    D: Domain,
616{
617    fn datac_mut(&mut self, index: Range<usize>) -> &mut [Complex<T>] {
618        let len = self.valid_len;
619        let slice = self.data.to_slice_mut();
620        let slice = array_to_complex_mut(&mut slice[0..len]);
621        &mut slice[index]
622    }
623}
624
625impl<S, T, D> Index<usize> for DspVec<S, T, RealSpace, D>
626where
627    S: ToSlice<T>,
628    T: RealNumber,
629    D: Domain,
630{
631    type Output = T;
632
633    fn index(&self, index: usize) -> &T {
634        self.data(index)
635    }
636}
637
638impl<S, T, D> IndexMut<usize> for DspVec<S, T, RealSpace, D>
639where
640    S: ToSliceMut<T>,
641    T: RealNumber,
642    D: Domain,
643{
644    fn index_mut(&mut self, index: usize) -> &mut T {
645        self.data_mut(index)
646    }
647}
648
649impl<S, T, D> Index<RangeFull> for DspVec<S, T, RealSpace, D>
650where
651    S: ToSlice<T>,
652    T: RealNumber,
653    D: Domain,
654{
655    type Output = [T];
656
657    fn index(&self, index: RangeFull) -> &[T] {
658        self.data(index)
659    }
660}
661
662impl<S, T, D> IndexMut<RangeFull> for DspVec<S, T, RealSpace, D>
663where
664    S: ToSliceMut<T>,
665    T: RealNumber,
666    D: Domain,
667{
668    fn index_mut(&mut self, index: RangeFull) -> &mut [T] {
669        self.data_mut(index)
670    }
671}
672
673impl<S, T, D> Index<RangeFrom<usize>> for DspVec<S, T, RealSpace, D>
674where
675    S: ToSlice<T>,
676    T: RealNumber,
677    D: Domain,
678{
679    type Output = [T];
680
681    fn index(&self, index: RangeFrom<usize>) -> &[T] {
682        self.data(index)
683    }
684}
685
686impl<S, T, D> IndexMut<RangeFrom<usize>> for DspVec<S, T, RealSpace, D>
687where
688    S: ToSliceMut<T>,
689    T: RealNumber,
690    D: Domain,
691{
692    fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut [T] {
693        self.data_mut(index)
694    }
695}
696
697impl<S, T, D> Index<RangeTo<usize>> for DspVec<S, T, RealSpace, D>
698where
699    S: ToSlice<T>,
700    T: RealNumber,
701    D: Domain,
702{
703    type Output = [T];
704
705    fn index(&self, index: RangeTo<usize>) -> &[T] {
706        self.data(index)
707    }
708}
709
710impl<S, T, D> IndexMut<RangeTo<usize>> for DspVec<S, T, RealSpace, D>
711where
712    S: ToSliceMut<T>,
713    T: RealNumber,
714    D: Domain,
715{
716    fn index_mut(&mut self, index: RangeTo<usize>) -> &mut [T] {
717        self.data_mut(index)
718    }
719}
720
721impl<S, T, D> Index<Range<usize>> for DspVec<S, T, RealSpace, D>
722where
723    S: ToSlice<T>,
724    T: RealNumber,
725    D: Domain,
726{
727    type Output = [T];
728
729    fn index(&self, index: Range<usize>) -> &[T] {
730        self.data(index)
731    }
732}
733
734impl<S, T, D> IndexMut<Range<usize>> for DspVec<S, T, RealSpace, D>
735where
736    S: ToSliceMut<T>,
737    T: RealNumber,
738    D: Domain,
739{
740    fn index_mut(&mut self, index: Range<usize>) -> &mut [T] {
741        self.data_mut(index)
742    }
743}
744
745impl<S, T, D> Index<usize> for DspVec<S, T, ComplexSpace, D>
746where
747    S: ToSlice<T>,
748    T: RealNumber,
749    D: Domain,
750{
751    type Output = Complex<T>;
752
753    fn index(&self, index: usize) -> &Complex<T> {
754        self.datac(index)
755    }
756}
757
758impl<S, T, D> IndexMut<usize> for DspVec<S, T, ComplexSpace, D>
759where
760    S: ToSliceMut<T>,
761    T: RealNumber,
762    D: Domain,
763{
764    fn index_mut(&mut self, index: usize) -> &mut Complex<T> {
765        self.datac_mut(index)
766    }
767}
768
769impl<S, T, D> Index<RangeFull> for DspVec<S, T, ComplexSpace, D>
770where
771    S: ToSlice<T>,
772    T: RealNumber,
773    D: Domain,
774{
775    type Output = [Complex<T>];
776
777    fn index(&self, index: RangeFull) -> &[Complex<T>] {
778        self.datac(index)
779    }
780}
781
782impl<S, T, D> IndexMut<RangeFull> for DspVec<S, T, ComplexSpace, D>
783where
784    S: ToSliceMut<T>,
785    T: RealNumber,
786    D: Domain,
787{
788    fn index_mut(&mut self, index: RangeFull) -> &mut [Complex<T>] {
789        self.datac_mut(index)
790    }
791}
792
793impl<S, T, D> Index<RangeFrom<usize>> for DspVec<S, T, ComplexSpace, D>
794where
795    S: ToSlice<T>,
796    T: RealNumber,
797    D: Domain,
798{
799    type Output = [Complex<T>];
800
801    fn index(&self, index: RangeFrom<usize>) -> &[Complex<T>] {
802        self.datac(index)
803    }
804}
805
806impl<S, T, D> IndexMut<RangeFrom<usize>> for DspVec<S, T, ComplexSpace, D>
807where
808    S: ToSliceMut<T>,
809    T: RealNumber,
810    D: Domain,
811{
812    fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut [Complex<T>] {
813        self.datac_mut(index)
814    }
815}
816
817impl<S, T, D> Index<RangeTo<usize>> for DspVec<S, T, ComplexSpace, D>
818where
819    S: ToSlice<T>,
820    T: RealNumber,
821    D: Domain,
822{
823    type Output = [Complex<T>];
824
825    fn index(&self, index: RangeTo<usize>) -> &[Complex<T>] {
826        self.datac(index)
827    }
828}
829
830impl<S, T, D> IndexMut<RangeTo<usize>> for DspVec<S, T, ComplexSpace, D>
831where
832    S: ToSliceMut<T>,
833    T: RealNumber,
834    D: Domain,
835{
836    fn index_mut(&mut self, index: RangeTo<usize>) -> &mut [Complex<T>] {
837        self.datac_mut(index)
838    }
839}
840
841impl<S, T, D> Index<Range<usize>> for DspVec<S, T, ComplexSpace, D>
842where
843    S: ToSlice<T>,
844    T: RealNumber,
845    D: Domain,
846{
847    type Output = [Complex<T>];
848
849    fn index(&self, index: Range<usize>) -> &[Complex<T>] {
850        self.datac(index)
851    }
852}
853
854impl<S, T, D> IndexMut<Range<usize>> for DspVec<S, T, ComplexSpace, D>
855where
856    S: ToSliceMut<T>,
857    T: RealNumber,
858    D: Domain,
859{
860    fn index_mut(&mut self, index: Range<usize>) -> &mut [Complex<T>] {
861        self.datac_mut(index)
862    }
863}
864
865#[cfg(test)]
866mod tests {
867    use super::super::*;
868
869    #[test]
870    fn len_of_vec() {
871        let vec: Vec<f32> = vec![1.0, 2.0, 3.0];
872        let dsp = vec.to_real_time_vec();
873        assert_eq!(dsp.len(), 3);
874    }
875
876    #[test]
877    fn len_of_slice() {
878        let slice = [1.0, 5.0, 4.0];
879        let dsp = slice.to_real_freq_vec();
880        assert_eq!(dsp.len(), 3);
881    }
882
883    #[test]
884    #[allow(unused_mut)]
885    fn len_of_slice_mut() {
886        let mut slice = [1.0, 5.0, 4.0];
887        let dsp = slice.to_real_freq_vec();
888        assert_eq!(dsp.len(), 3);
889    }
890
891    #[test]
892    #[allow(unused_mut)]
893    fn len_of_invalid_storage() {
894        let mut slice = [1.0, 5.0, 4.0];
895        let dsp = slice.to_complex_freq_vec();
896        assert_eq!(dsp.len(), 0);
897    }
898
899    #[test]
900    fn index_of_vec() {
901        let vec = vec![1.0, 2.0, 3.0];
902        let dsp = vec.to_real_time_vec();
903        assert_eq!(dsp.data(..), [1.0, 2.0, 3.0]);
904    }
905
906    #[test]
907    fn index_of_slice() {
908        let slice = [1.0, 5.0, 4.0];
909        let dsp = slice.to_real_time_vec();
910        assert_eq!(dsp.data(..), [1.0, 5.0, 4.0]);
911    }
912}
basic_dsp_vector/vector_types/vec_impl_and_indexers.rs

basic_dsp_vector/vector_types/
vec_impl_and_indexers.rs
