VCTR
Loading...
Searching...
No Matches
AppleAccelerate.h
1/*
2 ==============================================================================
3 DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
5 Copyright 2022- by sonible GmbH.
6
7 This file is part of VCTR - Versatile Container Templates Reconceptualized.
8
9 VCTR is free software: you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License version 3
11 only, as published by the Free Software Foundation.
12
13 VCTR is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU Lesser General Public License version 3 for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 version 3 along with VCTR. If not, see <https://www.gnu.org/licenses/>.
20 ==============================================================================
21*/
22
23namespace vctr::platform_vec_ops
24{
25
26template <class T>
27class AppleAccelerate
28{
29};
30
31#if VCTR_APPLE
32
33template <>
34class AppleAccelerate<float>
35{
36public:
37 //==============================================================================
38 // vForce functions
39 //==============================================================================
40 // clang-format off
41 static void abs (const float* src, float* dst, int len) { vvfabsf (dst, src, &len); }
42 static void ln (const float* src, float* dst, int len) { vvlogf (dst, src, &len); }
43 static void log10 (const float* src, float* dst, int len) { vvlog10f (dst, src, &len); }
44 static void log2 (const float* src, float* dst, int len) { vvlog2f (dst, src, &len); }
45 static void exp (const float* src, float* dst, int len) { vvexpf (dst, src, &len); }
46 static void exp2 (const float* src, float* dst, int len) { vvexp2f (dst, src, &len); }
47 static void pow (const float* base, const float* exp, float* dst, int len) { vvpowf (dst, exp, base, &len); }
48 static void sqrt (const float* src, float* dst, int len) { vvsqrtf (dst, src, &len); }
49 static void sin (const float* src, float* dst, int len) { vvsinf (dst, src, &len); }
50 static void cos (const float* src, float* dst, int len) { vvcosf (dst, src, &len); }
51 static void tan (const float* src, float* dst, int len) { vvtanf (dst, src, &len); }
52 static void asin (const float* src, float* dst, int len) { vvasinf (dst, src, &len); }
53 static void acos (const float* src, float* dst, int len) { vvacosf (dst, src, &len); }
54 static void atan (const float* src, float* dst, int len) { vvatanf (dst, src, &len); }
55 static void sinh (const float* src, float* dst, int len) { vvsinhf (dst, src, &len); }
56 static void cosh (const float* src, float* dst, int len) { vvcoshf (dst, src, &len); }
57 static void tanh (const float* src, float* dst, int len) { vvtanhf (dst, src, &len); }
58 static void asinh (const float* src, float* dst, int len) { vvasinhf (dst, src, &len); }
59 static void acosh (const float* src, float* dst, int len) { vvacoshf (dst, src, &len); }
60 static void atanh (const float* src, float* dst, int len) { vvatanhf (dst, src, &len); }
61 static void copysign (const float* src, const float* sign, float* dst, int len) { vvcopysignf (dst, src, sign, &len); }
62 // clang-format on
63
64 //==============================================================================
65 // vDSP functions
66 //==============================================================================
67 // clang-format off
68 static void abs (const float* src, float* dst, size_t len) { vDSP_vabs (src, 1, dst, 1, len); }
69 static void add (const float* srcA, const float* srcB, float* dst, size_t len) { vDSP_vadd (srcA, 1, srcB, 1, dst, 1, len); }
70 static void add (const float* srcA, float srcB, float* dst, size_t len) { vDSP_vsadd (srcA, 1, &srcB, dst, 1, len); }
71 static void sub (const float* srcA, const float* srcB, float* dst, size_t len) { vDSP_vsub (srcB, 1, srcA, 1, dst, 1, len); }
72 static void mul (const float* srcA, const float* srcB, float* dst, size_t len) { vDSP_vmul (srcA, 1, srcB, 1, dst, 1, len); }
73 static void mul (const float* srcA, float srcB, float* dst, size_t len) { vDSP_vsmul (srcA, 1, &srcB, dst, 1, len); }
74 static void div (const float* srcA, const float* srcB, float* dst, size_t len) { vDSP_vdiv (srcB, 1, srcA, 1, dst, 1, len); }
75 static void div (const float* srcA, float srcB, float* dst, size_t len) { vDSP_vsdiv (srcA, 1, &srcB, dst, 1, len); }
76
77 static void multiplyAdd (const float* srcA, float srcB, float srcC, float* dst, size_t len) { vDSP_vsmsa (srcA, 1, &srcB, &srcC, dst, 1, len); }
78 static void multiplyAdd (const float* srcA, const float* srcB, const float* srcC, float* dst, size_t len) { vDSP_vma (srcA, 1, srcB, 1, srcC, 1, dst, 1, len); }
79 static void multiplyAdd (const float* srcA, float srcB, const float* srcC, float* dst, size_t len) { vDSP_vsma (srcA, 1, &srcB, srcC, 1, dst, 1, len); }
80
81 static void clampLow (const float* src, float thresh, float* dst, size_t len) { vDSP_vthr (src, 1, &thresh, dst, 1, len); }
82 static void clamp (const float* src, float l, float h, float* dst, size_t len) { vDSP_vclip (src, 1, &l, &h, dst, 1, len); }
83 static void square (const float* src, float* dst, size_t len) { vDSP_vsq (src, 1, dst, 1, len); }
84
85 static void intToFloat (const int32_t* src, float* dst, size_t len) { vDSP_vflt32 (src, 1, dst, 1, len); }
86 static void intToFloat (const uint32_t* src, float* dst, size_t len) { vDSP_vfltu32 (src, 1, dst, 1, len); }
87
88 static float max (const float* src, size_t len) { float r; vDSP_maxv (src, 1, &r, len); return r; }
89 static float min (const float* src, size_t len) { float r; vDSP_minv (src, 1, &r, len); return r; }
90 static float sum (const float* src, size_t len) { float r; vDSP_sve (src, 1, &r, len); return r; }
91 static float mean (const float* src, size_t len) { float r; vDSP_meanv (src, 1, &r, len); return r; }
92 static float meanSquare (const float* src, size_t len) { float r; vDSP_measqv (src, 1, &r, len); return r; }
93 static float rms (const float* src, size_t len) { float r; vDSP_rmsqv (src, 1, &r, len); return r; }
94 // clang-format on
95};
96
97template <>
98class AppleAccelerate<double>
99{
100public:
101 //==============================================================================
102 // vForce functions
103 //==============================================================================
104 // clang-format off
105 static void abs (const double* src, double* dst, int len) { vvfabs (dst, src, &len); }
106 static void ln (const double* src, double* dst, int len) { vvlog (dst, src, &len); }
107 static void log10 (const double* src, double* dst, int len) { vvlog10 (dst, src, &len); }
108 static void log2 (const double* src, double* dst, int len) { vvlog2 (dst, src, &len); }
109 static void exp (const double* src, double* dst, int len) { vvexp (dst, src, &len); }
110 static void exp2 (const double* src, double* dst, int len) { vvexp2 (dst, src, &len); }
111 static void pow (const double* base, const double* exp, double* dst, int len) { vvpow (dst, exp, base, &len); }
112 static void sqrt (const double* src, double* dst, int len) { vvsqrt (dst, src, &len); }
113 static void sin (const double* src, double* dst, int len) { vvsin (dst, src, &len); }
114 static void cos (const double* src, double* dst, int len) { vvcos (dst, src, &len); }
115 static void tan (const double* src, double* dst, int len) { vvtan (dst, src, &len); }
116 static void asin (const double* src, double* dst, int len) { vvasin (dst, src, &len); }
117 static void acos (const double* src, double* dst, int len) { vvacos (dst, src, &len); }
118 static void atan (const double* src, double* dst, int len) { vvatan (dst, src, &len); }
119 static void sinh (const double* src, double* dst, int len) { vvsinh (dst, src, &len); }
120 static void cosh (const double* src, double* dst, int len) { vvcosh (dst, src, &len); }
121 static void tanh (const double* src, double* dst, int len) { vvtanh (dst, src, &len); }
122 static void asinh (const double* src, double* dst, int len) { vvasinh (dst, src, &len); }
123 static void acosh (const double* src, double* dst, int len) { vvacosh (dst, src, &len); }
124 static void atanh (const double* src, double* dst, int len) { vvatanh (dst, src, &len); }
125 static void copysign (const double* src, const double* sign, double* dst, int len) { vvcopysign (dst, src, sign, &len); }
126 // clang-format on
127
128 //==============================================================================
129 // vDSP functions
130 //==============================================================================
131 // clang-format off
132 static void abs (const double* src, double* dst, size_t len) { vDSP_vabsD (src, 1, dst, 1, len); }
133 static void add (const double* srcA, const double* srcB, double* dst, size_t len) { vDSP_vaddD (srcA, 1, srcB, 1, dst, 1, len); }
134 static void add (const double* srcA, double srcB, double* dst, size_t len) { vDSP_vsaddD (srcA, 1, &srcB, dst, 1, len); }
135 static void sub (const double* srcA, const double* srcB, double* dst, size_t len) { vDSP_vsubD (srcB, 1, srcA, 1, dst, 1, len); }
136 static void mul (const double* srcA, const double* srcB, double* dst, size_t len) { vDSP_vmulD (srcA, 1, srcB, 1, dst, 1, len); }
137 static void mul (const double* srcA, double srcB, double* dst, size_t len) { vDSP_vsmulD (srcA, 1, &srcB, dst, 1, len); }
138 static void div (const double* srcA, const double* srcB, double* dst, size_t len) { vDSP_vdivD (srcB, 1, srcA, 1, dst, 1, len); }
139 static void div (const double* srcA, double srcB, double* dst, size_t len) { vDSP_vsdivD (srcA, 1, &srcB, dst, 1, len); }
140
141 static void multiplyAdd (const double* srcA, double srcB, double srcC, double* dst, size_t len) { vDSP_vsmsaD (srcA, 1, &srcB, &srcC, dst, 1, len); }
142 static void multiplyAdd (const double* srcA, const double* srcB, const double* srcC, double* dst, size_t len) { vDSP_vmaD (srcA, 1, srcB, 1, srcC, 1, dst, 1, len); }
143 static void multiplyAdd (const double* srcA, double srcB, const double* srcC, double* dst, size_t len) { vDSP_vsmaD (srcA, 1, &srcB, srcC, 1, dst, 1, len); }
144 // clang-format on
145
146 static void clampLow (const double* src, double thresh, double* dst, size_t len) { vDSP_vthrD (src, 1, &thresh, dst, 1, len); }
147 static void clamp (const double* src, double l, double h, double* dst, size_t len) { vDSP_vclipD (src, 1, &l, &h, dst, 1, len); }
148 static void square (const double* src, double* dst, size_t len) { vDSP_vsqD (src, 1, dst, 1, len); }
149
150 static void intToFloat (const int32_t* src, double* dst, size_t len)
151 {
152 VCTR_ASSERT ((void*) src != (void*) dst);
153 vDSP_vflt32D (src, 1, dst, 1, len);
154 }
155
156 static void intToFloat (const uint32_t* src, double* dst, size_t len)
157 {
158 VCTR_ASSERT ((void*) src != (void*) dst);
159 vDSP_vfltu32D (src, 1, dst, 1, len);
160 }
161
162 static double max (const double* src, size_t len) { double r; vDSP_maxvD (src, 1, &r, len); return r; }
163 static double min (const double* src, size_t len) { double r; vDSP_minvD (src, 1, &r, len); return r; }
164 static double sum (const double* src, size_t len) { double r; vDSP_sveD (src, 1, &r, len); return r; }
165 static double mean (const double* src, size_t len) { double r; vDSP_meanvD (src, 1, &r, len); return r; }
166 static double meanSquare (const double* src, size_t len) { double r; vDSP_measqvD (src, 1, &r, len); return r; }
167 static double rms (const double* src, size_t len) { double r; vDSP_rmsqvD (src, 1, &r, len); return r; }
168};
169
170template <>
171class AppleAccelerate<std::complex<float>>
172{
173private:
174 // clang-format off
175 static auto sp (std::complex<float>* c) { return DSPSplitComplex { reinterpret_cast<float*> (c), reinterpret_cast<float*> (c) + 1 }; }
176 static const auto sp (const std::complex<float>* c) { return sp (const_cast<std::complex<float>*> (c)); }
177 static auto sp (std::complex<float>& c) { return DSPSplitComplex { &reinterpret_cast<float&> (c), &reinterpret_cast<float&> (c) + 1 }; }
178 static const auto sp (const std::complex<float>& c) { return sp (const_cast<std::complex<float>&> (c)); }
179 // clang-format on
180
181public:
182 //==============================================================================
183 // vDSP functions
184 //==============================================================================
185 static void abs (const std::complex<float>* src, float* dst, size_t len)
186 {
187 auto s = sp (src);
188 vDSP_zvabs (&s, 2, dst, 1, len);
189 }
190
191 static void add (const std::complex<float>* srcA, const std::complex<float>* srcB, std::complex<float>* dst, size_t len)
192 {
193 auto sa = sp (srcA);
194 auto sb = sp (srcB);
195 auto d = sp (dst);
196 vDSP_zvadd (&sa, 2, &sb, 2, &d, 2, len);
197 }
198
199 static void add (const std::complex<float>* srcA, std::complex<float> srcB, std::complex<float>* dst, size_t len)
200 {
201 auto sa = sp (srcA);
202 auto sb = sp (srcB);
203 auto d = sp (dst);
204 vDSP_vsadd (sa.realp, 2, sb.realp, d.realp, 2, len);
205 vDSP_vsadd (sa.imagp, 2, sb.imagp, d.imagp, 2, len);
206 }
207
208 static void sub (const std::complex<float>* srcA, const std::complex<float>* srcB, std::complex<float>* dst, size_t len)
209 {
210 auto sa = sp (srcA);
211 auto sb = sp (srcB);
212 auto d = sp (dst);
213 vDSP_zvsub (&sa, 2, &sb, 2, &d, 2, len);
214 }
215
216 static void mul (const std::complex<float>* srcA, const std::complex<float>* srcB, std::complex<float>* dst, size_t len)
217 {
218 auto sa = sp (srcA);
219 auto sb = sp (srcB);
220 auto d = sp (dst);
221 vDSP_zvmul (&sa, 2, &sb, 2, &d, 2, len, 1);
222 }
223
224 static void multiplyAdd (const std::complex<float>* srcA, const std::complex<float>* srcB, const std::complex<float>* srcC, std::complex<float>* dst, size_t len)
225 {
226 auto sa = sp (srcA);
227 auto sb = sp (srcB);
228 auto sc = sp (srcC);
229 auto d = sp (dst);
230 vDSP_zvma (&sa, 2, &sb, 2, &sc, 2, &d, 2, len);
231 }
232
233 static void div (const std::complex<float>* srcA, const std::complex<float>* srcB, std::complex<float>* dst, size_t len)
234 {
235 auto sa = sp (srcA);
236 auto sb = sp (srcB);
237 auto d = sp (dst);
238 vDSP_zvdiv (&sb, 2, &sa, 2, &d, 2, len);
239 }
240
241 static void conj (const std::complex<float>* src, std::complex<float>* dst, size_t len)
242 {
243 auto s = sp (src);
244 auto d = sp (dst);
245 vDSP_zvconj (&s, 2, &d, 2, len);
246 }
247
248 static void angle (const std::complex<float>* src, float* dst, size_t len)
249 {
250 auto s = sp (src);
251 vDSP_zvphas (&s, 2, dst, 1, len);
252 }
253
254 static void powerSpectrum (const std::complex<float>* src, float* dst, size_t len)
255 {
256 auto s = sp (src);
257 vDSP_zvmags (&s, 2, dst, 1, len);
258 }
259
260 //==============================================================================
261 // BLAS functions
262 //==============================================================================
263
264 static void copyReal (const std::complex<float>* src, float* dst, int len) { cblas_scopy (len, reinterpret_cast<const float*> (src), 2, dst, 1); }
265 static void copyImag (const std::complex<float>* src, float* dst, int len) { cblas_scopy (len, reinterpret_cast<const float*> (src) + 1, 2, dst, 1); }
266 static void copyRealToComplex (const float* src, std::complex<float>* dst, int len) { cblas_scopy (len, src, 2, reinterpret_cast<float*> (dst), 1); }
267};
268
269template <>
270class AppleAccelerate<std::complex<double>>
271{
272private:
273 // clang-format off
274 static auto sp (std::complex<double>* c) { return DSPDoubleSplitComplex { reinterpret_cast<double*> (c), reinterpret_cast<double*> (c) + 1}; }
275 static const auto sp (const std::complex<double>* c) { return sp (const_cast<std::complex<double>*> (c)); }
276 static auto sp (std::complex<double>& c) { return DSPDoubleSplitComplex { &reinterpret_cast<double&> (c), &reinterpret_cast<double&> (c) + 1 }; }
277 static const auto sp (const std::complex<double>& c) { return sp (const_cast<std::complex<double>&> (c)); }
278 // clang-format on
279
280public:
281 //==============================================================================
282 // vDSP functions
283 //==============================================================================
284 static void abs (const std::complex<double>* src, double* dst, size_t len)
285 {
286 auto sc = sp (src);
287 vDSP_zvabsD (&sc, 2, dst, 1, len);
288 }
289
290 static void add (const std::complex<double>* srcA, const std::complex<double>* srcB, std::complex<double>* dst, size_t len)
291 {
292 auto sa = sp (srcA);
293 auto sb = sp (srcB);
294 auto d = sp (dst);
295 vDSP_zvaddD (&sa, 2, &sb, 2, &d, 2, len);
296 }
297
298 static void add (const std::complex<double>* srcA, std::complex<double> srcB, std::complex<double>* dst, size_t len)
299 {
300 auto sa = sp (srcA);
301 auto sb = sp (srcB);
302 auto d = sp (dst);
303 vDSP_vsaddD (sa.realp, 2, sb.realp, d.realp, 2, len);
304 vDSP_vsaddD (sa.imagp, 2, sb.imagp, d.imagp, 2, len);
305 }
306
307 static void sub (const std::complex<double>* srcA, const std::complex<double>* srcB, std::complex<double>* dst, size_t len)
308 {
309 auto sa = sp (srcA);
310 auto sb = sp (srcB);
311 auto d = sp (dst);
312 vDSP_zvsubD (&sa, 2, &sb, 2, &d, 2, len);
313 }
314
315 static void mul (const std::complex<double>* srcA, const std::complex<double>* srcB, std::complex<double>* dst, size_t len)
316 {
317 auto sa = sp (srcA);
318 auto sb = sp (srcB);
319 auto d = sp (dst);
320 vDSP_zvmulD (&sa, 2, &sb, 2, &d, 2, len, 1);
321 }
322
323 static void multiplyAdd (const std::complex<double>* srcA, const std::complex<double>* srcB, const std::complex<double>* srcC, std::complex<double>* dst, size_t len)
324 {
325 auto sa = sp (srcA);
326 auto sb = sp (srcB);
327 auto sc = sp (srcC);
328 auto d = sp (dst);
329 vDSP_zvmaD (&sa, 2, &sb, 2, &sc, 2, &d, 2, len);
330 }
331
332 static void div (const std::complex<double>* srcA, const std::complex<double>* srcB, std::complex<double>* dst, size_t len)
333 {
334 auto sa = sp (srcA);
335 auto sb = sp (srcB);
336 auto d = sp (dst);
337 vDSP_zvdivD (&sb, 2, &sa, 2, &d, 2, len);
338 }
339
340 static void conj (const std::complex<double>* src, std::complex<double>* dst, size_t len)
341 {
342 auto s = sp (src);
343 auto d = sp (dst);
344 vDSP_zvconjD (&s, 2, &d, 2, len);
345 }
346
347 static void angle (const std::complex<double>* src, double* dst, size_t len)
348 {
349 auto s = sp (src);
350 vDSP_zvphasD (&s, 2, dst, 1, len);
351 }
352
353 static void powerSpectrum (const std::complex<double>* src, double* dst, size_t len)
354 {
355 auto s = sp (src);
356 vDSP_zvmagsD (&s, 2, dst, 1, len);
357 }
358
359 //==============================================================================
360 // BLAS functions
361 //==============================================================================
362
363 static void copyReal (const std::complex<double>* src, double* dst, int len) { cblas_dcopy (len, reinterpret_cast<const double*> (src), 2, dst, 1); }
364 static void copyImag (const std::complex<double>* src, double* dst, int len) { cblas_dcopy (len, reinterpret_cast<const double*> (src) + 1, 2, dst, 1); }
365 static void copyRealToComplex (const double* src, std::complex<double>* dst, int len) { cblas_dcopy (len, src, 2, reinterpret_cast<double*> (dst), 1); }
366};
367
368#endif
369} // namespace vctr::platform_vec_ops
vctr::log10
constexpr ExpressionChainBuilder< expressions::Log10 > log10
Computes the logarithm to the base of ten of the source values.
Definition: Log10.h:84
vctr::sin
constexpr ExpressionChainBuilder< expressions::Sin > sin
Computes the sine of each source element.
Definition: Sin.h:90
vctr::asinh
constexpr ExpressionChainBuilder< expressions::Asinh > asinh
Computes the inverse hyperbolic sine of each source element.
Definition: Asinh.h:90
vctr::exp
constexpr ExpressionChainBuilder< expressions::Exp > exp
Computes e (Euler's number, 2.7182818...) raised to the source vector elements power.
Definition: Exp.h:104
vctr::asin
constexpr ExpressionChainBuilder< expressions::Asin > asin
Computes the inverse sine of each source element.
Definition: Asin.h:90
vctr::acosh
constexpr ExpressionChainBuilder< expressions::Acosh > acosh
Computes the inverse hyperbolic cosine of each source element.
Definition: Acosh.h:90
vctr::rms
constexpr ExpressionChainBuilder< expressions::RootMeanSquare > rms
Computes the square root of the mean value of the squared source values.
Definition: Mean.h:260
vctr::mean
constexpr ExpressionChainBuilder< expressions::Mean > mean
Computes the mean value of the source values.
Definition: Mean.h:248
vctr::atan
constexpr ExpressionChainBuilder< expressions::Atan > atan
Computes the inverse tangent of each source element.
Definition: Atan.h:90
vctr::ln
constexpr ExpressionChainBuilder< expressions::Ln > ln
Computes the natural logarithm of the source values.
Definition: Ln.h:84
vctr::clampLow
constexpr auto clampLow(T lowerBound)
Ensures that the elements are not lower than lowerBound.
Definition: Clamp.h:287
vctr::cosh
constexpr ExpressionChainBuilder< expressions::Cosh > cosh
Computes the hyperbolic cosine of each source element.
Definition: Cosh.h:90
vctr::acos
constexpr ExpressionChainBuilder< expressions::Acos > acos
Computes the inverse cosine of each source element.
Definition: Acos.h:90
vctr::cos
constexpr ExpressionChainBuilder< expressions::Cos > cos
Computes the cosine of each source element.
Definition: Cos.h:90
vctr::tan
constexpr ExpressionChainBuilder< expressions::Tan > tan
Computes the tangent of each source element.
Definition: Tan.h:90
vctr::sqrt
constexpr ExpressionChainBuilder< expressions::Sqrt > sqrt
Computes the square root of the source values.
Definition: Sqrt.h:91
vctr::atanh
constexpr ExpressionChainBuilder< expressions::Atanh > atanh
Computes the inverse hyperbolic tangent of each source element.
Definition: Atanh.h:90
vctr::pow
constexpr auto pow(SrcBaseType &&bases, SrcExpType &&exponents)
Returns an expression that raises the elements in bases element-wise to the power of the elements in ...
Definition: Pow.h:213
vctr::sum
constexpr ExpressionChainBuilder< expressions::Sum > sum
Computes the sum of the source values.
Definition: Sum.h:118
vctr::max
constexpr ExpressionChainBuilder< expressions::Max > max
Computes the maximum value of the source values.
Definition: Max.h:198
vctr::abs
constexpr ExpressionChainBuilder< expressions::Abs > abs
Computes the absolute value of the source values.
Definition: Abs.h:135
vctr::angle
constexpr ExpressionChainBuilder< expressions::Angle > angle
Computes the phase angles of the complex source values.
Definition: Angle.h:67
vctr::log2
constexpr ExpressionChainBuilder< expressions::Log2 > log2
Computes the logarithm to the base of two of the source values.
Definition: Log2.h:91
vctr::square
constexpr ExpressionChainBuilder< expressions::Square > square
Squares the source values.
Definition: Square.h:115
vctr::clamp
constexpr auto clamp(T lowerBound, T upperBound)
Ensures that the elements are not lower than lowerBound and not higher than upperBound.
Definition: Clamp.h:313
vctr::sinh
constexpr ExpressionChainBuilder< expressions::Sinh > sinh
Computes the hyperbolic sine of each source element.
Definition: Sinh.h:90
vctr::min
constexpr ExpressionChainBuilder< expressions::Min > min
Computes the minimum value of the source values.
Definition: Min.h:198
vctr::meanSquare
constexpr ExpressionChainBuilder< expressions::MeanSquare > meanSquare
Computes the mean value of the squared source values.
Definition: Mean.h:254
vctr::powerSpectrum
constexpr ExpressionChainBuilder< expressions::PowerSpectrum > powerSpectrum
Computes the power spectrum of the complex source values.
Definition: PowerSpectrum.h:72
vctr::tanh
constexpr ExpressionChainBuilder< expressions::Tanh > tanh
Computes the hyperbolic tangent of each source element.
Definition: Tanh.h:90