Loading [MathJax]/extensions/TeX/AMSsymbols.js
LALPulsar 7.1.1.1-8a6b96f
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
testVectorMath.c
Go to the documentation of this file.
1/*
2* Copyright (C) 2013, 2014 Evan Goetz
3*
4* This program is free software; you can redistribute it and/or modify
5* it under the terms of the GNU General Public License as published by
6* the Free Software Foundation; either version 2 of the License, or
7* (at your option) any later version.
8*
9* This program is distributed in the hope that it will be useful,
10* but WITHOUT ANY WARRANTY; without even the implied warranty of
11* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12* GNU General Public License for more details.
13*
14* You should have received a copy of the GNU General Public License
15* along with with program; see the file COPYING. If not, write to the
16* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
17* MA 02110-1301 USA
18*/
19
20#include <stdio.h>
21#include <math.h>
22#include <string.h>
23#include <time.h>
24
25#include <lal/LALConstants.h>
26#include <lal/SeqFactories.h>
27#include <lal/LALStdlib.h>
28
29#include "../vectormath.h"
30
31#define Relfloaterr(dx,x) (fabsf(x)>0 ? fabsf((dx)/(x)) : fabsf(dx) )
32#define Relerr(dx,x) (fabs(x)>0 ? fabs((dx)/(x)) : fabs(dx) )
33
34int main( void )
35{
36
37 //struct timespec st,end,st2,end2;
38
39 INT4 ii, length = 100000;
40 REAL4VectorAligned *floatvalues0 = NULL, *floatvalues1 = NULL, *floatvalues2 = NULL, *floatvalues3 = NULL;
41 alignedREAL8Vector *doublevalues1 = NULL, *doublevalues2 = NULL, *doublevalues3 = NULL;
42 alignedREAL4VectorArray *floatvalues = NULL;
43 XLAL_CHECK( ( floatvalues0 = XLALCreateREAL4VectorAligned( length, 32 ) ) != NULL, XLAL_EFUNC );
44 XLAL_CHECK( ( floatvalues1 = XLALCreateREAL4VectorAligned( length, 32 ) ) != NULL, XLAL_EFUNC );
45 XLAL_CHECK( ( floatvalues2 = XLALCreateREAL4VectorAligned( length, 32 ) ) != NULL, XLAL_EFUNC );
46 XLAL_CHECK( ( floatvalues3 = XLALCreateREAL4VectorAligned( length, 32 ) ) != NULL, XLAL_EFUNC );
47 XLAL_CHECK( ( doublevalues1 = createAlignedREAL8Vector( length, 32 ) ) != NULL, XLAL_EFUNC );
48 XLAL_CHECK( ( doublevalues2 = createAlignedREAL8Vector( length, 32 ) ) != NULL, XLAL_EFUNC );
49 XLAL_CHECK( ( doublevalues3 = createAlignedREAL8Vector( length, 32 ) ) != NULL, XLAL_EFUNC );
50 XLAL_CHECK( ( floatvalues = createAlignedREAL4VectorArray( 2, length, 32 ) ) != NULL, XLAL_EFUNC );
51
52 for ( ii = 0; ii < length; ii++ ) {
53 floatvalues1->data[ii] = ( REAL4 )( ii - length / 2 ) * 2.0e-3;
54 doublevalues1->data[ii] = ( REAL8 )( ii - length / 2 ) * 2.0e-3;
55 floatvalues2->data[ii] = ( REAL4 )( ii ) * 1.0e-3;
56 doublevalues2->data[ii] = ( REAL8 )( ii ) * 1.0e-3;
57 floatvalues3->data[ii] = ( REAL4 )( ii - length / 2 ) * 2.0e-4;
58 doublevalues3->data[ii] = ( REAL8 )( ii - length / 2 ) * 2.0e-4;
59 }
60 memcpy( floatvalues->data[0]->data, floatvalues1->data, sizeof( REAL4 )*length );
61 memcpy( floatvalues->data[1]->data, floatvalues2->data, sizeof( REAL4 )*length );
62 memcpy( floatvalues0->data, floatvalues1->data, sizeof( REAL4 )*length );
63
64 REAL4VectorAligned *floatresult_vecsum = NULL, *floatresult_vecmult = NULL, *floatresult_addscalar = NULL, *floatresult_scale = NULL;
65 alignedREAL8Vector *doubleresult_exp = NULL, *doubleresult_addscalar = NULL, *doubleresult_scale = NULL;
66 alignedREAL4VectorArray *arraysumresult = NULL;
67 XLAL_CHECK( ( doubleresult_exp = createAlignedREAL8Vector( doublevalues1->length, 32 ) ) != NULL, XLAL_EFUNC );
68 XLAL_CHECK( ( floatresult_vecsum = XLALCreateREAL4VectorAligned( floatvalues1->length, 32 ) ) != NULL, XLAL_EFUNC );
69 XLAL_CHECK( ( floatresult_vecmult = XLALCreateREAL4VectorAligned( floatvalues1->length, 32 ) ) != NULL, XLAL_EFUNC );
70 XLAL_CHECK( ( floatresult_addscalar = XLALCreateREAL4VectorAligned( floatvalues1->length, 32 ) ) != NULL, XLAL_EFUNC );
71 XLAL_CHECK( ( floatresult_scale = XLALCreateREAL4VectorAligned( floatvalues1->length, 32 ) ) != NULL, XLAL_EFUNC );
72 XLAL_CHECK( ( doubleresult_addscalar = createAlignedREAL8Vector( doublevalues1->length, 32 ) ) != NULL, XLAL_EFUNC );
73 XLAL_CHECK( ( doubleresult_scale = createAlignedREAL8Vector( doublevalues1->length, 32 ) ) != NULL, XLAL_EFUNC );
74 XLAL_CHECK( ( arraysumresult = createAlignedREAL4VectorArray( 2, length, 32 ) ) != NULL, XLAL_EFUNC );
75 memset( arraysumresult->data[0]->data, 0, sizeof( REAL4 )*length );
76 memset( arraysumresult->data[1]->data, 0, sizeof( REAL4 )*length );
77
78 //clock_gettime(CLOCK_REALTIME, &st);
79
80 XLAL_CHECK( sse_exp_REAL8Vector( doubleresult_exp, doublevalues3 ) == XLAL_SUCCESS, XLAL_EFUNC );
81 XLAL_CHECK( XLALVectorAddREAL4( floatvalues1->data, floatvalues1->data, floatvalues1->data, floatvalues1->length ) == XLAL_SUCCESS, XLAL_EFUNC );
82 XLAL_CHECK( XLALVectorMultiplyREAL4( floatresult_vecmult->data, floatvalues1->data, floatvalues2->data, floatvalues1->length ) == XLAL_SUCCESS, XLAL_EFUNC );
83 XLAL_CHECK( XLALVectorShiftREAL4( floatresult_addscalar->data, ( REAL4 )100.0, floatvalues1->data, floatvalues1->length ) == XLAL_SUCCESS, XLAL_EFUNC );
84 XLAL_CHECK( XLALVectorScaleREAL4( floatresult_scale->data, ( REAL4 )100.0, floatvalues1->data, floatvalues1->length ) == XLAL_SUCCESS, XLAL_EFUNC );
85 XLAL_CHECK( sseAddScalarToREAL8Vector( doubleresult_addscalar, doublevalues1, 100.0 ) == XLAL_SUCCESS, XLAL_EFUNC );
86 XLAL_CHECK( sseScaleREAL8Vector( doubleresult_scale, doublevalues1, 100.0 ) == XLAL_SUCCESS, XLAL_EFUNC );
87 XLAL_CHECK( sseSSVectorArraySum( arraysumresult, floatvalues, floatvalues, 0, 1, 0, 1 ) == XLAL_SUCCESS, XLAL_EFUNC );
88
89 //clock_gettime(CLOCK_REALTIME, &end);
90
91 REAL4 maxfloaterr_vecsum = 0.0, maxfloatrelerr_vecsum = 0.0, maxfloaterr_vecmult = 0.0, maxfloatrelerr_vecmult = 0.0, maxfloaterr_addscalar = 0.0, maxfloatrelerr_addscalar = 0.0, maxfloaterr_scale = 0.0, maxfloatrelerr_scale = 0.0, maxfloaterr_seqsum = 0.0, maxfloatrelerr_seqsum = 0.0;
92 REAL8 maxdoubleerr_exp = 0.0, maxdoublerelerr_exp = 0.0, maxdoubleerr_addscalar = 0.0, maxdoublerelerr_addscalar = 0.0, maxdoubleerr_scale = 0.0, maxdoublerelerr_scale = 0.0;
93 for ( ii = 0; ii < length; ii++ ) {
94 REAL8 exp_libm = exp( doublevalues3->data[ii] );
95 REAL8 doubleerr = fabs( doubleresult_exp->data[ii] - exp_libm );
96 REAL8 doublerelerr = Relerr( doubleerr, exp_libm );
97 maxdoubleerr_exp = fmax( doubleerr, maxdoubleerr_exp );
98 maxdoublerelerr_exp = fmax( doublerelerr, maxdoublerelerr_exp );
99
100 REAL4 sumval = ( REAL4 )( floatvalues0->data[ii] + floatvalues0->data[ii] );
101 REAL4 floaterr = fabsf( floatvalues1->data[ii] - sumval );
102 REAL4 floatrelerr = Relfloaterr( floaterr, sumval );
103 maxfloaterr_vecsum = fmaxf( floaterr, maxfloaterr_vecsum );
104 maxfloatrelerr_vecsum = fmaxf( floatrelerr, maxfloatrelerr_vecsum );
105
106 REAL4 multval = ( REAL4 )( floatvalues1->data[ii] * floatvalues2->data[ii] );
107 floaterr = fabsf( floatresult_vecmult->data[ii] - multval );
108 floatrelerr = Relfloaterr( floaterr, multval );
109 maxfloaterr_vecmult = fmaxf( floaterr, maxfloaterr_vecmult );
110 maxfloatrelerr_vecmult = fmaxf( floatrelerr, maxfloatrelerr_vecmult );
111
112 sumval = ( REAL4 )( floatvalues1->data[ii] + ( REAL4 )100.0 );
113 REAL8 sumvald = ( doublevalues1->data[ii] + 100.0 );
114 floaterr = fabsf( floatresult_addscalar->data[ii] - sumval );
115 floatrelerr = Relfloaterr( floaterr, sumval );
116 doubleerr = fabs( doubleresult_addscalar->data[ii] - sumvald );
117 doublerelerr = Relerr( doubleerr, sumvald );
118 maxfloaterr_addscalar = fmaxf( floaterr, maxfloaterr_addscalar );
119 maxfloatrelerr_addscalar = fmaxf( floatrelerr, maxfloatrelerr_addscalar );
120 maxdoubleerr_addscalar = fmax( doubleerr, maxdoubleerr_addscalar );
121 maxdoublerelerr_addscalar = fmax( doublerelerr, maxdoublerelerr_addscalar );
122
123 multval = ( REAL4 )( floatvalues1->data[ii] * ( REAL4 )100.0 );
124 REAL8 multvald = ( doublevalues1->data[ii] * 100.0 );
125 floaterr = fabsf( floatresult_scale->data[ii] - multval );
126 floatrelerr = Relfloaterr( floaterr, multval );
127 doubleerr = fabs( doubleresult_scale->data[ii] - multvald );
128 doublerelerr = Relerr( doubleerr, multvald );
129 maxfloaterr_scale = fmaxf( floaterr, maxfloaterr_scale );
130 maxfloatrelerr_scale = fmaxf( floatrelerr, maxfloatrelerr_scale );
131 maxdoubleerr_scale = fmax( doubleerr, maxdoubleerr_scale );
132 maxdoublerelerr_scale = fmax( doublerelerr, maxdoublerelerr_scale );
133
134 floaterr = fabsf( arraysumresult->data[0]->data[ii] - ( REAL4 )( floatvalues0->data[ii] + floatvalues2->data[ii] ) );
135 floatrelerr = Relfloaterr( floaterr, ( REAL4 )( floatvalues0->data[ii] + floatvalues2->data[ii] ) );
136 maxfloaterr_seqsum = fmaxf( floaterr, maxfloaterr_seqsum );
137 maxfloatrelerr_seqsum = fmaxf( floatrelerr, maxfloatrelerr_seqsum );
138 }
139
140 fprintf( stderr, "Test results SSE:\n" );
141 fprintf( stderr, "-----------------\n" );
142 fprintf( stderr, "Add REAL4Vectors: max error = %g, max relative error = %g\n", maxfloaterr_vecsum, maxfloatrelerr_vecsum );
143 fprintf( stderr, "Multiply REAL4Vectors: max error = %g, max relative error = %g\n", maxfloaterr_vecmult, maxfloatrelerr_vecmult );
144 fprintf( stderr, "Add scalar to REAL4Vector: max error = %g, max relative error = %g\n", maxfloaterr_addscalar, maxfloatrelerr_addscalar );
145 fprintf( stderr, "Add scalar to REAL8Vector: max error = %g, max relative error = %g\n", maxdoubleerr_addscalar, maxdoublerelerr_addscalar );
146 fprintf( stderr, "Scale REAL4Vector: max error = %g, max relative error = %g\n", maxfloaterr_scale, maxfloatrelerr_scale );
147 fprintf( stderr, "Scale REAL8Vector: max error = %g, max relative error = %g\n", maxdoubleerr_scale, maxdoublerelerr_scale );
148 fprintf( stderr, "exp(REAL8Vector): max error = %g, max relative error = %g\n", maxdoubleerr_exp, maxdoublerelerr_exp );
149 fprintf( stderr, "Sum vectors of vector array into vector array: max error = %g, max relative error = %g\n", maxfloaterr_seqsum, maxfloatrelerr_seqsum );
150 //fprintf(stderr, "Time elapsed: %li\n", (end.tv_sec-st.tv_sec)*GIGA+(end.tv_nsec-st.tv_nsec));
151
152#ifdef __AVX__
153 //clock_gettime(CLOCK_REALTIME, &st2);
154
155 XLAL_CHECK( avxSSVectorSum( floatresult_vecsum, floatvalues1, floatvalues2 ) == XLAL_SUCCESS, XLAL_EFUNC );
156 XLAL_CHECK( avxSSVectorMultiply( floatresult_vecmult, floatvalues1, floatvalues2 ) == XLAL_SUCCESS, XLAL_EFUNC );
157 XLAL_CHECK( avxAddScalarToREAL4Vector( floatresult_addscalar, floatvalues1, ( REAL4 )100.0 ) == XLAL_SUCCESS, XLAL_EFUNC );
158 XLAL_CHECK( avxScaleREAL4Vector( floatresult_scale, floatvalues1, ( REAL4 )100.0 ) == XLAL_SUCCESS, XLAL_EFUNC );
159 XLAL_CHECK( avxAddScalarToREAL8Vector( doubleresult_addscalar, doublevalues1, 100.0 ) == XLAL_SUCCESS, XLAL_EFUNC );
160 XLAL_CHECK( avxScaleREAL8Vector( doubleresult_scale, doublevalues1, 100.0 ) == XLAL_SUCCESS, XLAL_EFUNC );
161 XLAL_CHECK( avxSSVectorArraySum( arraysumresult, floatvalues, floatvalues, 0, 1, 0, 1 ) == XLAL_SUCCESS, XLAL_EFUNC );
162
163 //clock_gettime(CLOCK_REALTIME, &end2);
164
165 //REAL4 maxfloaterr_vecsum = 0.0, maxfloatrelerr_vecsum = 0.0, maxfloaterr_vecmult = 0.0, maxfloatrelerr_vecmult = 0.0, maxfloaterr_addscalar = 0.0, maxfloatrelerr_addscalar = 0.0, maxfloaterr_scale = 0.0, maxfloatrelerr_scale = 0.0, maxfloaterr_seqsum = 0.0, maxfloatrelerr_seqsum = 0.0, maxfloaterr_seqsub = 0.0, maxfloatrelerr_seqsub = 0.0;
166 //REAL8 maxdoubleerr_addscalar = 0.0, maxdoublerelerr_addscalar = 0.0, maxdoubleerr_scale = 0.0, maxdoublerelerr_scale = 0.0;
167 for ( ii = 0; ii < length; ii++ ) {
168 REAL4 floaterr = fabsf( floatresult_vecsum->data[ii] - ( REAL4 )( floatvalues1->data[ii] + floatvalues2->data[ii] ) );
169 REAL4 floatrelerr = fabsf( ( REAL4 )( 1.0 - floatresult_vecsum->data[ii] / ( REAL4 )( floatvalues1->data[ii] + floatvalues2->data[ii] ) ) );
170 if ( floaterr > maxfloaterr_vecsum ) {
171 maxfloaterr_vecsum = floaterr;
172 }
173 if ( floatrelerr > maxfloatrelerr_vecsum ) {
174 maxfloatrelerr_vecsum = floatrelerr;
175 }
176
177 floaterr = fabsf( floatresult_vecmult->data[ii] - ( REAL4 )( floatvalues1->data[ii] * floatvalues2->data[ii] ) );
178 floatrelerr = fabsf( ( REAL4 )( 1.0 - floatresult_vecmult->data[ii] / ( REAL4 )( floatvalues1->data[ii] * floatvalues2->data[ii] ) ) );
179 if ( floaterr > maxfloaterr_vecmult ) {
180 maxfloaterr_vecmult = floaterr;
181 }
182 if ( floatrelerr > maxfloatrelerr_vecmult ) {
183 maxfloatrelerr_vecmult = floatrelerr;
184 }
185
186 floaterr = fabsf( floatresult_addscalar->data[ii] - ( REAL4 )( floatvalues1->data[ii] + ( REAL4 )100.0 ) );
187 REAL8 doubleerr = fabs( doubleresult_addscalar->data[ii] - ( doublevalues1->data[ii] + 100.0 ) );
188 floatrelerr = fabsf( ( REAL4 )( 1.0 - floatresult_addscalar->data[ii] / ( REAL4 )( floatvalues1->data[ii] + ( REAL4 )100.0 ) ) );
189 REAL8 doublerelerr = fabs( 1.0 - doubleresult_addscalar->data[ii] / ( doublevalues1->data[ii] + 100.0 ) );
190 if ( floaterr > maxfloaterr_addscalar ) {
191 maxfloaterr_addscalar = floaterr;
192 }
193 if ( floatrelerr > maxfloatrelerr_addscalar ) {
194 maxfloatrelerr_addscalar = floatrelerr;
195 }
196 if ( doubleerr > maxdoubleerr_addscalar ) {
197 maxdoubleerr_addscalar = doubleerr;
198 }
199 if ( doublerelerr > maxdoublerelerr_addscalar ) {
200 maxdoublerelerr_addscalar = doublerelerr;
201 }
202
203 floaterr = fabsf( floatresult_scale->data[ii] - ( REAL4 )( floatvalues1->data[ii] * ( REAL4 )100.0 ) );
204 doubleerr = fabs( doubleresult_scale->data[ii] - ( doublevalues1->data[ii] * 100.0 ) );
205 floatrelerr = fabsf( ( REAL4 )( 1.0 - floatresult_scale->data[ii] / ( REAL4 )( floatvalues1->data[ii] * ( REAL4 )100.0 ) ) );
206 doublerelerr = fabs( 1.0 - doubleresult_scale->data[ii] / ( doublevalues1->data[ii] * 100.0 ) );
207 if ( floaterr > maxfloaterr_scale ) {
208 maxfloaterr_scale = floaterr;
209 }
210 if ( floatrelerr > maxfloatrelerr_scale ) {
211 maxfloatrelerr_scale = floatrelerr;
212 }
213 if ( doubleerr > maxdoubleerr_scale ) {
214 maxdoubleerr_scale = doubleerr;
215 }
216 if ( doublerelerr > maxdoublerelerr_scale ) {
217 maxdoublerelerr_scale = doublerelerr;
218 }
219
220 floaterr = fabsf( arraysumresult->data[ii] - ( REAL4 )( floatvalues1->data[ii] + floatvalues2->data[ii] ) );
221 floatrelerr = fabsf( ( REAL4 )( 1.0 - arraysumresult->data[ii] / ( REAL4 )( floatvalues1->data[ii] + floatvalues2->data[ii] ) ) );
222 if ( floaterr > maxfloaterr_seqsum ) {
223 maxfloaterr_seqsum = floaterr;
224 }
225 if ( floatrelerr > maxfloatrelerr_seqsum ) {
226 maxfloatrelerr_seqsum = floatrelerr;
227 }
228 }
229
230 fprintf( stderr, "Test results AVX:\n" );
231 fprintf( stderr, "-----------------\n" );
232 fprintf( stderr, "Add REAL4Vectors: max error = %g, max relative error = %g\n", maxfloaterr_vecsum, maxfloatrelerr_vecsum );
233 fprintf( stderr, "Multiply REAL4Vectors: max error = %g, max relative error = %g\n", maxfloaterr_vecmult, maxfloatrelerr_vecmult );
234 fprintf( stderr, "Add scalar to REAL4Vector: max error = %g, max relative error = %g\n", maxfloaterr_addscalar, maxfloatrelerr_addscalar );
235 fprintf( stderr, "Add scalar to REAL8Vector: max error = %g, max relative error = %g\n", maxdoubleerr_addscalar, maxdoublerelerr_addscalar );
236 fprintf( stderr, "Scale REAL4Vector: max error = %g, max relative error = %g\n", maxfloaterr_scale, maxfloatrelerr_scale );
237 fprintf( stderr, "Scale REAL8Vector: max error = %g, max relative error = %g\n", maxdoubleerr_scale, maxdoublerelerr_scale );
238 fprintf( stderr, "Sum vectors of vector array into vector array: max error = %g, max relative error = %g\n", maxfloaterr_seqsum, maxfloatrelerr_seqsum );
239 //fprintf(stderr, "Time elapsed: %li\n", (end2.tv_sec-st2.tv_sec)*GIGA+(end2.tv_nsec-st2.tv_nsec));
240#endif
241
242 XLALDestroyREAL4VectorAligned( floatvalues0 );
243 XLALDestroyREAL4VectorAligned( floatvalues1 );
244 destroyAlignedREAL8Vector( doublevalues1 );
245 XLALDestroyREAL4VectorAligned( floatvalues2 );
246 destroyAlignedREAL8Vector( doublevalues2 );
247 destroyAlignedREAL8Vector( doubleresult_exp );
248 XLALDestroyREAL4VectorAligned( floatresult_vecsum );
249 XLALDestroyREAL4VectorAligned( floatresult_vecmult );
250 XLALDestroyREAL4VectorAligned( floatresult_addscalar );
251 XLALDestroyREAL4VectorAligned( floatresult_scale );
252 destroyAlignedREAL8Vector( doubleresult_addscalar );
253 destroyAlignedREAL8Vector( doubleresult_scale );
254 destroyAlignedREAL4VectorArray( floatvalues );
255 destroyAlignedREAL4VectorArray( arraysumresult );
256
257 return 0;
258
259}
fprintf
#define fprintf
REAL8
double REAL8
INT4
int32_t INT4
REAL4
float REAL4
XLALVectorScaleREAL4
int XLALVectorScaleREAL4(REAL4 *out, REAL4 scalar, const REAL4 *in, const UINT4 len)
XLALDestroyREAL4VectorAligned
void XLALDestroyREAL4VectorAligned(REAL4VectorAligned *in)
XLALCreateREAL4VectorAligned
REAL4VectorAligned * XLALCreateREAL4VectorAligned(const UINT4 length, const UINT4 align)
XLALVectorAddREAL4
int XLALVectorAddREAL4(REAL4 *out, const REAL4 *in1, const REAL4 *in2, const UINT4 len)
XLALVectorMultiplyREAL4
int XLALVectorMultiplyREAL4(REAL4 *out, const REAL4 *in1, const REAL4 *in2, const UINT4 len)
XLALVectorShiftREAL4
int XLALVectorShiftREAL4(REAL4 *out, REAL4 scalar, const REAL4 *in, const UINT4 len)
XLAL_CHECK
#define XLAL_CHECK(assertion,...)
XLAL_SUCCESS
XLAL_SUCCESS
XLAL_EFUNC
XLAL_EFUNC
lalpulsar_PiecewiseSearch.fmax
fmax
Definition: lalpulsar_PiecewiseSearch.py:496
Relerr
#define Relerr(dx, x)
Definition: testVectorMath.c:32
main
int main(void)
Definition: testVectorMath.c:34
Relfloaterr
#define Relfloaterr(dx, x)
Definition: testVectorMath.c:31
avxScaleREAL8Vector
INT4 avxScaleREAL8Vector(alignedREAL8Vector *output, alignedREAL8Vector *input, REAL8 scale)
Scale the elements of a alignedREAL8Vector by a REAL8 value using AVX.
Definition: vectormath.c:1240
sseScaleREAL8Vector
INT4 sseScaleREAL8Vector(alignedREAL8Vector *output, alignedREAL8Vector *input, REAL8 scale)
Scale the elements of a alignedREAL8Vector by a REAL8 value using SSE.
Definition: vectormath.c:1197
destroyAlignedREAL8Vector
void destroyAlignedREAL8Vector(alignedREAL8Vector *vector)
Definition: vectormath.c:67
sse_exp_REAL8Vector
INT4 sse_exp_REAL8Vector(alignedREAL8Vector *output, alignedREAL8Vector *input)
Exponential of input vector is computed using SSE, based on the Cephes library.
Definition: vectormath.c:1609
avxAddScalarToREAL8Vector
INT4 avxAddScalarToREAL8Vector(alignedREAL8Vector *output, alignedREAL8Vector *input, REAL8 scalar)
Add a REAL8 scalar value to the elements of a alignedREAL8Vector using AVX.
Definition: vectormath.c:1149
sseAddScalarToREAL8Vector
INT4 sseAddScalarToREAL8Vector(alignedREAL8Vector *output, alignedREAL8Vector *input, REAL8 scalar)
Add a REAL8 scalar value to the elements of a alignedREAL8Vector using SSE.
Definition: vectormath.c:1106
createAlignedREAL8Vector
alignedREAL8Vector * createAlignedREAL8Vector(UINT4 length, const size_t align)
Definition: vectormath.c:55