VISR  0.11.6
Versatile Interactive Scene Renderer
vector_functions_reference_impl.hpp
Go to the documentation of this file.
1 /* Copyright Institute of Sound and Vibration Research - All rights reserved */
2 
3 #ifndef VISR_LIBEFL_VECTOR_FUNCTIONS_REFERENCE_IMPL_HPP_INCLUDED
4 #define VISR_LIBEFL_VECTOR_FUNCTIONS_REFERENCE_IMPL_HPP_INCLUDED
5 
7 
8 #include "alignment.hpp"
9 
10 #include <complex>
11 
12 // avoid annoying warning about unsafe STL functions.
13 #ifdef _MSC_VER
14 #pragma warning(disable: 4996)
15 #endif
16 
17 #include <algorithm>
18 #include <ciso646> // should not be necessary for c++11, but MSVC needs it somehow
19 #include <functional>
20 
21 namespace visr
22 {
23 namespace efl
24 {
25 namespace reference
26 {
27 
28 template <typename T>
29 ErrorCode vectorZero( T * const dest, std::size_t numElements, std::size_t alignment /*= 0*/ )
30 {
31  if( not checkAlignment( dest, alignment ) ) return alignmentError;
32  std::fill( &dest[0], &dest[0] + numElements, static_cast<T>(0) );
33  return noError;
34 }
35 
36 template <typename T>
37 ErrorCode vectorFill( const T value, T * const dest, std::size_t numElements, std::size_t alignment /*= 0*/ )
38 {
39  if( not checkAlignment( dest, alignment ) ) return alignmentError;
40  std::fill( &dest[0], &dest[0] + numElements, value );
41  return noError;
42 }
43 
44 template <typename T>
45 ErrorCode vectorRamp( T * const dest, std::size_t numElements, T startVal, T endVal,
46  bool startInclusive, bool endInclusive, std::size_t alignment /*= 0*/ )
47 {
48  if( not checkAlignment( dest, alignment ) ) return alignmentError;
49  if( numElements < 2 ) return logicError; // ramps with less than 2 elements make no sense.
50  std::size_t const numSteps = numElements + 1 - (startInclusive ? 1 : 0) - (endInclusive ? 1 : 0);
51  T const step = (endVal - startVal) / static_cast<T>(numSteps);
52  std::size_t calcIdx( startInclusive ? 0 : 1 );
53  std::generate( dest, dest + numElements, [&] { return startVal + static_cast<T>(calcIdx++) * step; } );
54  return noError;
55 }
56 
57 template <typename T>
58 ErrorCode vectorCopy( T const * const source, T * const dest, std::size_t numElements, std::size_t alignment /*= 0*/ )
59 {
60  if( not checkAlignment( source, alignment ) ) return alignmentError;
61  if( not checkAlignment( dest, alignment ) ) return alignmentError;
62  std::copy( &source[0], &source[0] + numElements, &dest[0] );
63  return noError;
64 }
65 
66 template<typename T>
67 ErrorCode vectorAdd( T const * const op1,
68  T const * const op2,
69  T * const result,
70  std::size_t numElements,
71  std::size_t alignment /*= 0*/ )
72 {
73  if( not checkAlignment( op1, alignment ) ) return alignmentError;
74  if( not checkAlignment( op2, alignment ) ) return alignmentError;
75  if( not checkAlignment( result, alignment ) ) return alignmentError;
76  std::transform( op1, op1+numElements, op2, result, [&](T const & a, T const& b){return a+b;} ); // c++11 way, using a lambda function
77  // std::transform( op1, op1+numElements, op2, result, std::plus<T>() ); // c++0x way, using standard function object
78 
79  return noError;
80 }
81 
82 template<typename T>
83 ErrorCode vectorAddInplace( T const * const op1,
84  T * const op2Result,
85  std::size_t numElements,
86  std::size_t alignment /*= 0*/ )
87 {
88  if (not checkAlignment(op1, alignment)) return alignmentError;
89  if (not checkAlignment(op2Result, alignment)) return alignmentError;
90  for( std::size_t idx( 0 ); idx < numElements; ++idx )
91  {
92  op2Result[idx] += op1[idx];
93  }
94  return noError;
95 }
96 
97 template<typename T>
98 ErrorCode vectorAddConstant( T constantValue,
99  T const * const op,
100  T * const result,
101  std::size_t numElements,
102  std::size_t alignment /*= 0*/ )
103 {
104  if (not checkAlignment(op, alignment)) return alignmentError;
105  if (not checkAlignment(result, alignment)) return alignmentError;
106 
107  std::transform(op, op + numElements, result, [=](T const & x){return x + constantValue; });
108 
109  return noError;
110 }
111 
112 template<typename T>
114  T * const opResult,
115  std::size_t numElements,
116  std::size_t alignment /*= 0*/ )
117 {
118  if( not checkAlignment( opResult, alignment ) ) return alignmentError;
119  std::for_each( opResult, opResult + numElements,
120  [=](T const & x){return x + constantValue;} );
121  return noError;
122 }
123 
124 template<typename T>
125 ErrorCode vectorSubtract( T const * const subtrahend,
126  T const * const minuend,
127  T * const result,
128  std::size_t numElements,
129  std::size_t alignment /*= 0*/ )
130 {
131  if( not checkAlignment( subtrahend, alignment ) ) return alignmentError;
132  if( not checkAlignment( minuend, alignment ) ) return alignmentError;
133  if( not checkAlignment( result, alignment ) ) return alignmentError;
134 
135  std::transform( subtrahend, subtrahend + numElements, minuend, result, [=]( T x, T y ) { return x + y; } );
136  return noError;
137 }
138 
139 template<typename T>
140 ErrorCode vectorSubtractInplace( T const * const minuend,
141  T * const subtrahendResult,
142  std::size_t numElements,
143  std::size_t alignment /*= 0*/ )
144 {
145  if( not checkAlignment( minuend, alignment ) ) return alignmentError;
146  if( not checkAlignment( subtrahendResult, alignment ) ) return alignmentError;
147  for( std::size_t idx( 0 ); idx < numElements; ++idx )
148  {
149  subtrahendResult[idx] -= minuend[idx];
150  }
151  return noError;
152 }
153 
154 template<typename T>
156  T const * const subtrahend,
157  T * const result,
158  std::size_t numElements,
159  std::size_t alignment /*= 0*/ )
160 {
161  if( not checkAlignment( subtrahend, alignment ) ) return alignmentError;
162  if( not checkAlignment( result, alignment ) ) return alignmentError;
163  std::transform( subtrahend, subtrahend + numElements, result, [=]( T x ) { return x - constantMinuend; } );
164  return noError;
165 }
166 
167 template<typename T>
169  T * const subtrahendResult,
170  std::size_t numElements,
171  std::size_t alignment /*= 0*/ )
172 {
173  if( not checkAlignment( subtrahendResult, alignment ) ) return alignmentError;
174  std::for_each( subtrahendResult, subtrahendResult + numElements, [=]( T& x ) { x -= constantMinuend; } );
175  return noError;
176 }
177 
178 template<typename T>
179 ErrorCode vectorMultiply( T const * const factor1,
180  T const * const factor2,
181  T * const result,
182  std::size_t numElements,
183  std::size_t alignment /*= 0*/ )
184 {
185  if( not checkAlignment( factor1, alignment ) ) return alignmentError;
186  if( not checkAlignment( factor2, alignment ) ) return alignmentError;
187  if( not checkAlignment( result, alignment ) ) return alignmentError;
188  for( std::size_t idx( 0 ); idx < numElements; ++idx )
189  {
190  result[idx] = factor1[idx] * factor2[idx];
191  }
192  return noError;
193 }
194 
195 template<typename T>
196 ErrorCode vectorMultiplyInplace( T const * const factor1,
197  T * const factor2Result,
198  std::size_t numElements,
199  std::size_t alignment /* = 0 */ )
200 {
201  if( not checkAlignment( factor1, alignment ) ) return alignmentError;
202  if( not checkAlignment( factor2Result, alignment ) ) return alignmentError;
203  for( std::size_t idx( 0 ); idx < numElements; ++idx )
204  {
205  factor2Result[idx] *= factor1[idx];
206  }
207  return noError;
208 }
209 
210 template<typename T>
212  T const * const factor,
213  T * const result,
214  std::size_t numElements,
215  std::size_t alignment /*= 0*/ )
216 {
217  if( not checkAlignment( factor, alignment ) ) return alignmentError;
218  if( not checkAlignment( result, alignment ) ) return alignmentError;
219  for( std::size_t idx( 0 ); idx < numElements; ++idx )
220  {
221  result[idx] = constantValue * factor[idx];
222  }
223  return noError;
224 }
225 
226 template<typename T>
228  T * const factorResult,
229  std::size_t numElements,
230  std::size_t alignment /*= 0*/ )
231 {
232  if( not checkAlignment( factorResult, alignment ) ) return alignmentError;
233  for( std::size_t idx( 0 ); idx < numElements; ++idx )
234  {
235  factorResult[idx] *= constantValue;
236  }
237  return noError;
238 }
239 
240 template<typename T>
241 ErrorCode vectorMultiplyAdd( T const * const factor1,
242  T const * const factor2,
243  T const * const addend,
244  T * const result,
245  std::size_t numElements,
246  std::size_t alignment /*= 0*/ )
247 {
248  if( not checkAlignment( factor1, alignment ) ) return alignmentError;
249  if( not checkAlignment( factor2, alignment ) ) return alignmentError;
250  if( not checkAlignment( addend, alignment ) ) return alignmentError;
251  if( not checkAlignment( result, alignment ) ) return alignmentError;
252  for( std::size_t idx( 0 ); idx < numElements; ++idx )
253  {
254  result[idx] = addend[idx] + factor1[idx] * factor2[idx];
255  }
256  return noError;
257 }
258 
259 template<typename T>
260 ErrorCode vectorMultiplyAddInplace( T const * const factor1,
261  T const * const factor2,
262  T * const accumulator,
263  std::size_t numElements,
264  std::size_t alignment /*= 0*/ )
265 {
266  if( not checkAlignment( factor1, alignment ) ) return alignmentError;
267  if( not checkAlignment( factor2, alignment ) ) return alignmentError;
268  if( not checkAlignment( accumulator, alignment ) ) return alignmentError;
269  for( std::size_t idx( 0 ); idx < numElements; ++idx )
270  {
271  accumulator[idx] += factor1[idx] * factor2[idx];
272  }
273  return noError;
274 }
275 
276 template<typename T>
278  T const * const factor,
279  T const * const addend,
280  T * const result,
281  std::size_t numElements,
282  std::size_t alignment /*= 0*/ )
283 {
284  if( not checkAlignment( factor, alignment ) ) return alignmentError;
285  if( not checkAlignment( addend, alignment ) ) return alignmentError;
286  if( not checkAlignment( result, alignment ) ) return alignmentError;
287  for( std::size_t idx( 0 ); idx < numElements; ++idx )
288  {
289  result[idx] = addend[idx] + constFactor * factor[idx];
290  }
291  return noError;
292 }
293 
294 template<typename T>
296  T const * const factor,
297  T * const accumulator,
298  std::size_t numElements,
299  std::size_t alignment /*= 0*/ )
300 {
301  if( not checkAlignment( factor, alignment ) ) return alignmentError;
302  if( not checkAlignment( accumulator, alignment ) ) return alignmentError;
303  for( std::size_t idx( 0 ); idx < numElements; ++idx )
304  {
305  accumulator[idx] += constFactor * factor[idx];
306  }
307  return noError;
308 }
309 
310 } // namespace reference
311 } // namespace efl
312 } // namespace visr
313 
314 #endif // #ifndef VISR_LIBEFL_VECTOR_FUNCTIONS_REFERENCE_IMPL_HPP_INCLUDED
template ErrorCode vectorMultiplyConstantAdd(float, float const *const, float const *const, float *const, std::size_t, std::size_t)
template ErrorCode vectorMultiplyAddInplace(float const *const, float const *const, float *const, std::size_t, std::size_t)
template ErrorCode vectorSubtract(float const *const, float const *const, float *const, std::size_t, std::size_t)
ErrorCode vectorAddConstantInplace(T constantValue, T *const opResult, std::size_t numElements, std::size_t alignment=0)
Definition: vector_functions_reference_impl.hpp:113
template ErrorCode vectorSubtractInplace(float const *const, float *const, std::size_t, std::size_t)
ErrorCode vectorAdd(T const *const op1, T const *const op2, T *const result, std::size_t numElements, std::size_t alignment=0)
Definition: vector_functions_reference_impl.hpp:67
template ErrorCode vectorMultiplyConstant(float, float const *const, float *const, std::size_t, std::size_t)
ErrorCode vectorZero(T *const dest, std::size_t numElements, std::size_t alignment)
Definition: vector_functions_reference_impl.hpp:29
bool checkAlignment(T const *ptr, std::size_t alignment)
Definition: alignment.hpp:45
template ErrorCode vectorSubtractConstant(float, float const *const, float *const, std::size_t, std::size_t)
Definition: error_codes.hpp:15
ErrorCode vectorAddConstant(T constantValue, T const *const op, T *const result, std::size_t numElements, std::size_t alignment=0)
Definition: vector_functions_reference_impl.hpp:98
template ErrorCode vectorMultiplyConstantAddInplace(float, float const *const, float *const, std::size_t, std::size_t)
Definition: error_codes.hpp:18
Definition: options.cpp:10
ErrorCode vectorFill(const T value, T *const dest, std::size_t numElements, std::size_t alignment)
Definition: vector_functions_reference_impl.hpp:37
ErrorCode vectorAddInplace(T const *const op1, T *const op2Result, std::size_t numElements, std::size_t alignment=0)
Definition: vector_functions_reference_impl.hpp:83
Definition: error_codes.hpp:16
template ErrorCode vectorRamp(float *const, std::size_t, float, float, bool, bool, std::size_t)
template ErrorCode vectorMultiplyAdd(float const *const, float const *const, float const *const, float *const, std::size_t, std::size_t)
template ErrorCode vectorSubConstantInplace(float, float *const, std::size_t, std::size_t)
template ErrorCode vectorMultiplyConstantInplace(float, float *const, std::size_t, std::size_t)
ErrorCode
Definition: error_codes.hpp:13
template ErrorCode vectorMultiplyInplace(float const *const, float *const, std::size_t, std::size_t)
template ErrorCode vectorMultiply(float const *const, float const *const, float *const, std::size_t, std::size_t)
ErrorCode vectorCopy(T const *const source, T *const dest, std::size_t numElements, std::size_t alignment)
Definition: vector_functions_reference_impl.hpp:58