Loading [MathJax]/extensions/TeX/AMSsymbols.js
LAL 7.7.0.1-5e288d3
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
VectorMultiply.c
Go to the documentation of this file.
1/*
2* Copyright (C) 2007 Jolien Creighton
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 <complex.h>
21#include <math.h>
22#include <lal/LALStdlib.h>
23#include <lal/VectorOps.h>
24
25/**
26 * \addtogroup VectorMultiply_c
27 * \author J. D. E. Creighton, T. D. Creighton, A. M. Sintes
28 *
29 * \brief Multiply two vectors.
30 *
31 * Let \c u, \c v, and \c w be objects of type
32 * \c COMPLEX8Vector, and let \c a, \c b, and \c c be
33 * objects of type \c REAL4Vector.
34 *
35 * The \ref LALCCVectorMultiply "LALCCVectorMultiply( &status, &w, &u, &v )" function computes:<br>
36 * <tt>w.data[i]= u.data[i] x v.data[i]</tt>
37 *
38 * The \ref LALCCVectorMultiplyConjugate "LALCCVectorMultiplyConjugate( &status, &w, &u, &v )" function computes:<br>
39 * <tt>w.data[i]=u.data[i] x v.data[i]*</tt>.
40 *
41 * The \ref LALCCVectorDivide "LALCCVectorDivide( &status, &w, &u, &v )" function computes:<br>
42 * <tt>w.data[i]= u.data[i] / v.data[i]</tt>
43 *
44 * The \ref LALSCVectorMultiply "LALSCVectorMultiply( &status, &w, &a, &v )" function computes:<br>
45 * <tt>w.data[i]=a.data[i] x v.data[i]</tt>
46 *
47 * The \ref LALSSVectorMultiply "LALSSVectorMultiply( &status, &c, &a, &b )" function computes:<br>
48 * <tt>c.data[i]=a.data[i] x b.data[i]</tt>
49 *
50 * The double-precison multiply routines (with \c D or \c Z names) work similarly.
51 *
52 * ### Algorithm ###
53 *
54 * The algorithm for complex division is described in
55 * Sec. 5.4 of Ref. \cite ptvf1992 . The formula used is:
56 * \f[
57 * \frac{a + ib}{c + id} = \left\{
58 * \begin{array}{ll}
59 * \frac{[a + b(d/c)] + i[b - a(d/c)]}{c + d(d/c)} & |c| \ge |d| \\
60 * \frac{[a(c/d) + b] + i[b(c/d) - a]}{c(c/d) + d} & |c| < |d|.
61 * \end{array}
62 * \right.
63 * \f]
64 */
65
66/** @{ */
67
68COMPLEX8Vector * XLALCCVectorDivide(
69 COMPLEX8Vector *out,
70 const COMPLEX8Vector *in1,
71 const COMPLEX8Vector *in2
72 )
73{
74 COMPLEX8 *a;
75 COMPLEX8 *b;
76 COMPLEX8 *c;
77 INT4 n;
78
79 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
80 XLAL_ERROR_NULL( XLAL_EFAULT );
81 if ( ! out->length )
82 XLAL_ERROR_NULL( XLAL_EBADLEN );
83 if ( in1->length != out->length || in2->length != out->length )
84 XLAL_ERROR_NULL( XLAL_EBADLEN );
85
86 a = in1->data;
87 b = in2->data;
88 c = out->data;
89 n = out->length;
90
91 while (n-- > 0)
92 *c++ = *a++ / *b++;
93
94 return out;
95}
96
97
98COMPLEX16Vector * XLALZZVectorDivide(
99 COMPLEX16Vector *out,
100 const COMPLEX16Vector *in1,
101 const COMPLEX16Vector *in2
102 )
103{
104 COMPLEX16 *a;
105 COMPLEX16 *b;
106 COMPLEX16 *c;
107 INT4 n;
108
109 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
110 XLAL_ERROR_NULL( XLAL_EFAULT );
111 if ( ! out->length )
112 XLAL_ERROR_NULL( XLAL_EBADLEN );
113 if ( in1->length != out->length || in2->length != out->length )
114 XLAL_ERROR_NULL( XLAL_EBADLEN );
115
116 a = in1->data;
117 b = in2->data;
118 c = out->data;
119 n = out->length;
120
121 while (n-- > 0)
122 *c++ = *a++ / *b++;
123
124 return out;
125}
126
127
128COMPLEX8Vector * XLALCCVectorMultiply(
129 COMPLEX8Vector *out,
130 const COMPLEX8Vector *in1,
131 const COMPLEX8Vector *in2
132 )
133{
134 COMPLEX8 *a;
135 COMPLEX8 *b;
136 COMPLEX8 *c;
137 INT4 n;
138
139 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
140 XLAL_ERROR_NULL( XLAL_EFAULT );
141 if ( ! out->length )
142 XLAL_ERROR_NULL( XLAL_EBADLEN );
143 if ( in1->length != out->length || in2->length != out->length )
144 XLAL_ERROR_NULL( XLAL_EBADLEN );
145
146 a = in1->data;
147 b = in2->data;
148 c = out->data;
149 n = out->length;
150
151 while (n-- > 0)
152 *c++ = *a++ * *b++;
153
154 return out;
155}
156
157
158COMPLEX16Vector * XLALZZVectorMultiply(
159 COMPLEX16Vector *out,
160 const COMPLEX16Vector *in1,
161 const COMPLEX16Vector *in2
162 )
163{
164 COMPLEX16 *a;
165 COMPLEX16 *b;
166 COMPLEX16 *c;
167 INT4 n;
168
169 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
170 XLAL_ERROR_NULL( XLAL_EFAULT );
171 if ( ! out->length )
172 XLAL_ERROR_NULL( XLAL_EBADLEN );
173 if ( in1->length != out->length || in2->length != out->length )
174 XLAL_ERROR_NULL( XLAL_EBADLEN );
175
176 a = in1->data;
177 b = in2->data;
178 c = out->data;
179 n = out->length;
180
181 while (n-- > 0)
182 *c++ = *a++ * *b++;
183
184 return out;
185}
186
187
188COMPLEX8Vector * XLALCCVectorMultiplyConjugate(
189 COMPLEX8Vector *out,
190 const COMPLEX8Vector *in1,
191 const COMPLEX8Vector *in2
192 )
193{
194 COMPLEX8 *a;
195 COMPLEX8 *b;
196 COMPLEX8 *c;
197 INT4 n;
198
199 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
200 XLAL_ERROR_NULL( XLAL_EFAULT );
201 if ( ! out->length )
202 XLAL_ERROR_NULL( XLAL_EBADLEN );
203 if ( in1->length != out->length || in2->length != out->length )
204 XLAL_ERROR_NULL( XLAL_EBADLEN );
205
206 a = in1->data;
207 b = in2->data;
208 c = out->data;
209 n = out->length;
210
211 while (n-- > 0)
212 *c++ = *a++ * conjf(*b++);
213
214 return out;
215}
216
217
218COMPLEX16Vector * XLALZZVectorMultiplyConjugate(
219 COMPLEX16Vector *out,
220 const COMPLEX16Vector *in1,
221 const COMPLEX16Vector *in2
222 )
223{
224 COMPLEX16 *a;
225 COMPLEX16 *b;
226 COMPLEX16 *c;
227 INT4 n;
228
229 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
230 XLAL_ERROR_NULL( XLAL_EFAULT );
231 if ( ! out->length )
232 XLAL_ERROR_NULL( XLAL_EBADLEN );
233 if ( in1->length != out->length || in2->length != out->length )
234 XLAL_ERROR_NULL( XLAL_EBADLEN );
235
236 a = in1->data;
237 b = in2->data;
238 c = out->data;
239 n = out->length;
240
241 while (n-- > 0)
242 *c++ = *a++ * conj(*b++);
243
244 return out;
245}
246
247
248COMPLEX8Vector * XLALSCVectorMultiply(
249 COMPLEX8Vector *out,
250 const REAL4Vector *in1,
251 const COMPLEX8Vector *in2
252 )
253{
254 REAL4 *a;
255 COMPLEX8 *b;
256 COMPLEX8 *c;
257 INT4 n;
258
259 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
260 XLAL_ERROR_NULL( XLAL_EFAULT );
261 if ( ! out->length )
262 XLAL_ERROR_NULL( XLAL_EBADLEN );
263 if ( in1->length != out->length || in2->length != out->length )
264 XLAL_ERROR_NULL( XLAL_EBADLEN );
265
266 a = in1->data;
267 b = in2->data;
268 c = out->data;
269 n = out->length;
270
271 while (n-- > 0)
272 *c++ = *a++ * *b++;
273
274 return out;
275}
276
277COMPLEX16Vector * XLALDZVectorMultiply(
278 COMPLEX16Vector *out,
279 const REAL8Vector *in1,
280 const COMPLEX16Vector *in2
281 )
282{
283 REAL8 *a;
284 COMPLEX16 *b;
285 COMPLEX16 *c;
286 INT4 n;
287
288 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
289 XLAL_ERROR_NULL( XLAL_EFAULT );
290 if ( ! out->length )
291 XLAL_ERROR_NULL( XLAL_EBADLEN );
292 if ( in1->length != out->length || in2->length != out->length )
293 XLAL_ERROR_NULL( XLAL_EBADLEN );
294
295 a = in1->data;
296 b = in2->data;
297 c = out->data;
298 n = out->length;
299
300 while (n-- > 0)
301 *c++ = *a++ * *b++;
302
303 return out;
304}
305
306
307REAL4Vector * XLALSSVectorMultiply(
308 REAL4Vector *out,
309 const REAL4Vector *in1,
310 const REAL4Vector *in2
311 )
312{
313 REAL4 *a;
314 REAL4 *b;
315 REAL4 *c;
316 INT4 n;
317
318 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
319 XLAL_ERROR_NULL( XLAL_EFAULT );
320 if ( ! out->length )
321 XLAL_ERROR_NULL( XLAL_EBADLEN );
322 if ( in1->length != out->length || in2->length != out->length )
323 XLAL_ERROR_NULL( XLAL_EBADLEN );
324
325 a = in1->data;
326 b = in2->data;
327 c = out->data;
328 n = out->length;
329
330 while (n-- > 0)
331 *c++ = (*a++)*(*b++);
332
333 return out;
334}
335
336
337REAL8Vector * XLALDDVectorMultiply(
338 REAL8Vector *out,
339 const REAL8Vector *in1,
340 const REAL8Vector *in2
341 )
342{
343 REAL8 *a;
344 REAL8 *b;
345 REAL8 *c;
346 INT4 n;
347
348 if ( ! out || ! in1 || !in2 || ! out->data || ! in1->data || ! in2->data )
349 XLAL_ERROR_NULL( XLAL_EFAULT );
350 if ( ! out->length )
351 XLAL_ERROR_NULL( XLAL_EBADLEN );
352 if ( in1->length != out->length || in2->length != out->length )
353 XLAL_ERROR_NULL( XLAL_EBADLEN );
354
355 a = in1->data;
356 b = in2->data;
357 c = out->data;
358 n = out->length;
359
360 while (n-- > 0)
361 *c++ = (*a++)*(*b++);
362
363 return out;
364}
365
366
367/*
368 *
369 * LAL Routines.
370 *
371 */
372
373
374
375/** UNDOCUMENTED */
376void
377LALCCVectorDivide (
378 LALStatus *status,
379 COMPLEX8Vector *out,
380 const COMPLEX8Vector *in1,
381 const COMPLEX8Vector *in2
382 )
383{
384 INITSTATUS(status);
385
386 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
387 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
388
389 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
390
391 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
392 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
393 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
394
395 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
396 ASSERT (in1->length == out->length, status,
397 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
398 ASSERT (in2->length == out->length, status,
399 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
400
401 XLALCCVectorDivide(out, in1, in2);
402
403 RETURN (status);
404}
405
406
407
408void
409LALZZVectorDivide (
410 LALStatus *status,
411 COMPLEX16Vector *out,
412 const COMPLEX16Vector *in1,
413 const COMPLEX16Vector *in2
414 )
415{
416 INITSTATUS(status);
417
418 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
419 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
420
421 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
422
423 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
424 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
425 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
426
427 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
428 ASSERT (in1->length == out->length, status,
429 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
430 ASSERT (in2->length == out->length, status,
431 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
432
433 XLALZZVectorDivide(out, in1, in2);
434
435 RETURN (status);
436}
437
438
439
440/** UNDOCUMENTED */
441void
442LALCCVectorMultiply (
443 LALStatus *status,
444 COMPLEX8Vector *out,
445 const COMPLEX8Vector *in1,
446 const COMPLEX8Vector *in2
447 )
448{
449 INITSTATUS(status);
450
451 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
452 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
453
454 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
455
456 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
457 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
458 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
459
460 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
461 ASSERT (in1->length == out->length, status,
462 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
463 ASSERT (in2->length == out->length, status,
464 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
465
466 XLALCCVectorMultiply(out, in1, in2);
467
468 RETURN (status);
469}
470
471
472
473void
474LALZZVectorMultiply (
475 LALStatus *status,
476 COMPLEX16Vector *out,
477 const COMPLEX16Vector *in1,
478 const COMPLEX16Vector *in2
479 )
480{
481 INITSTATUS(status);
482
483 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
484 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
485
486 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
487
488 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
489 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
490 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
491
492 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
493 ASSERT (in1->length == out->length, status,
494 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
495 ASSERT (in2->length == out->length, status,
496 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
497
498 XLALZZVectorMultiply(out, in1, in2);
499
500 RETURN (status);
501}
502
503
504/** UNDOCUMENTED */
505void
506LALCCVectorMultiplyConjugate (
507 LALStatus *status,
508 COMPLEX8Vector *out,
509 const COMPLEX8Vector *in1,
510 const COMPLEX8Vector *in2
511 )
512{
513 INITSTATUS(status);
514
515 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
516 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
517
518 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
519
520 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
521 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
522 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
523
524 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
525 ASSERT (in1->length == out->length, status,
526 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
527 ASSERT (in2->length == out->length, status,
528 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
529
530 XLALCCVectorMultiplyConjugate(out, in1, in2);
531
532 RETURN (status);
533}
534
535
536
537void
538LALZZVectorMultiplyConjugate (
539 LALStatus *status,
540 COMPLEX16Vector *out,
541 const COMPLEX16Vector *in1,
542 const COMPLEX16Vector *in2
543 )
544{
545 INITSTATUS(status);
546
547 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
548 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
549
550 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
551
552 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
553 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
554 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
555
556 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
557 ASSERT (in1->length == out->length, status,
558 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
559 ASSERT (in2->length == out->length, status,
560 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
561
562 XLALZZVectorMultiplyConjugate(out, in1, in2);
563
564 RETURN (status);
565}
566
567
568/** UNDOCUMENTED */
569void
570LALSCVectorMultiply (
571 LALStatus *status,
572 COMPLEX8Vector *out,
573 const REAL4Vector *in1,
574 const COMPLEX8Vector *in2
575 )
576{
577 INITSTATUS(status);
578
579 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
580 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
581
582 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
583
584 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
585 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
586 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
587
588 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
589 ASSERT (in1->length == out->length, status,
590 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
591 ASSERT (in2->length == out->length, status,
592 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
593
594 XLALSCVectorMultiply(out, in1, in2);
595
596 RETURN (status);
597}
598
599
600
601void
602LALDZVectorMultiply (
603 LALStatus *status,
604 COMPLEX16Vector *out,
605 const REAL8Vector *in1,
606 const COMPLEX16Vector *in2
607 )
608{
609 INITSTATUS(status);
610
611 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
612 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
613
614 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
615
616 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
617 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
618 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
619
620 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
621 ASSERT (in1->length == out->length, status,
622 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
623 ASSERT (in2->length == out->length, status,
624 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
625
626 XLALDZVectorMultiply(out, in1, in2);
627
628 RETURN (status);
629}
630
631
632/** UNDOCUMENTED */
633void
634LALSSVectorMultiply (
635 LALStatus *status,
636 REAL4Vector *out,
637 const REAL4Vector *in1,
638 const REAL4Vector *in2
639 )
640{
641 INITSTATUS(status);
642
643 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
644 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
645
646 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
647
648 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
649 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
650 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
651
652 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
653 ASSERT (in1->length == out->length, status,
654 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
655 ASSERT (in2->length == out->length, status,
656 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
657
658 XLALSSVectorMultiply(out, in1, in2);
659
660 RETURN (status);
661}
662
663
664
665void
666LALDDVectorMultiply (
667 LALStatus *status,
668 REAL8Vector *out,
669 const REAL8Vector *in1,
670 const REAL8Vector *in2
671 )
672{
673 INITSTATUS(status);
674
675 ASSERT (out, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
676 ASSERT (in1, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
677
678 ASSERT (in2, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
679
680 ASSERT (out->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
681 ASSERT (in1->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
682 ASSERT (in2->data, status, VECTOROPSH_ENULL, VECTOROPSH_MSGENULL);
683
684 ASSERT (out->length > 0, status, VECTOROPSH_ESIZE, VECTOROPSH_MSGESIZE);
685 ASSERT (in1->length == out->length, status,
686 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
687 ASSERT (in2->length == out->length, status,
688 VECTOROPSH_ESZMM, VECTOROPSH_MSGESZMM);
689
690 XLALDDVectorMultiply(out, in1, in2);
691
692 RETURN (status);
693}
694/** @} */
ASSERT
#define ASSERT(assertion, statusptr, code, mesg)
Definition: LALStatusMacros.h:119
INITSTATUS
#define INITSTATUS(statusptr)
Definition: LALStatusMacros.h:49
RETURN
#define RETURN(statusptr)
Definition: LALStatusMacros.h:71
VECTOROPSH_MSGESIZE
#define VECTOROPSH_MSGESIZE
Definition: VectorOps.h:59
VECTOROPSH_MSGESZMM
#define VECTOROPSH_MSGESZMM
Definition: VectorOps.h:60
VECTOROPSH_MSGENULL
#define VECTOROPSH_MSGENULL
Definition: VectorOps.h:58
COMPLEX16
double complex COMPLEX16
Double-precision floating-point complex number (16 bytes total)
Definition: LALAtomicDatatypes.h:120
REAL8
double REAL8
Double precision real floating-point number (8 bytes).
Definition: LALAtomicDatatypes.h:103
COMPLEX8
float complex COMPLEX8
Single-precision floating-point complex number (8 bytes total)
Definition: LALAtomicDatatypes.h:119
INT4
int32_t INT4
Four-byte signed integer.
Definition: LALAtomicDatatypes.h:57
REAL4
float REAL4
Single precision real floating-point number (4 bytes).
Definition: LALAtomicDatatypes.h:102
a
static const INT4 a
Definition: Random.c:79
LALZZVectorMultiply
void LALZZVectorMultiply(LALStatus *status, COMPLEX16Vector *out, const COMPLEX16Vector *in1, const COMPLEX16Vector *in2)
Definition: VectorMultiply.c:474
LALCCVectorDivide
void LALCCVectorDivide(LALStatus *status, COMPLEX8Vector *out, const COMPLEX8Vector *in1, const COMPLEX8Vector *in2)
UNDOCUMENTED.
Definition: VectorMultiply.c:377
LALDZVectorMultiply
void LALDZVectorMultiply(LALStatus *status, COMPLEX16Vector *out, const REAL8Vector *in1, const COMPLEX16Vector *in2)
Definition: VectorMultiply.c:602
XLALSCVectorMultiply
COMPLEX8Vector * XLALSCVectorMultiply(COMPLEX8Vector *out, const REAL4Vector *in1, const COMPLEX8Vector *in2)
Definition: VectorMultiply.c:248
LALZZVectorDivide
void LALZZVectorDivide(LALStatus *status, COMPLEX16Vector *out, const COMPLEX16Vector *in1, const COMPLEX16Vector *in2)
Definition: VectorMultiply.c:409
XLALDDVectorMultiply
REAL8Vector * XLALDDVectorMultiply(REAL8Vector *out, const REAL8Vector *in1, const REAL8Vector *in2)
Definition: VectorMultiply.c:337
XLALZZVectorDivide
COMPLEX16Vector * XLALZZVectorDivide(COMPLEX16Vector *out, const COMPLEX16Vector *in1, const COMPLEX16Vector *in2)
Definition: VectorMultiply.c:98
LALSSVectorMultiply
void LALSSVectorMultiply(LALStatus *status, REAL4Vector *out, const REAL4Vector *in1, const REAL4Vector *in2)
UNDOCUMENTED.
Definition: VectorMultiply.c:634
XLALCCVectorMultiply
COMPLEX8Vector * XLALCCVectorMultiply(COMPLEX8Vector *out, const COMPLEX8Vector *in1, const COMPLEX8Vector *in2)
Definition: VectorMultiply.c:128
LALSCVectorMultiply
void LALSCVectorMultiply(LALStatus *status, COMPLEX8Vector *out, const REAL4Vector *in1, const COMPLEX8Vector *in2)
UNDOCUMENTED.
Definition: VectorMultiply.c:570
LALCCVectorMultiplyConjugate
void LALCCVectorMultiplyConjugate(LALStatus *status, COMPLEX8Vector *out, const COMPLEX8Vector *in1, const COMPLEX8Vector *in2)
UNDOCUMENTED.
Definition: VectorMultiply.c:506
XLALZZVectorMultiplyConjugate
COMPLEX16Vector * XLALZZVectorMultiplyConjugate(COMPLEX16Vector *out, const COMPLEX16Vector *in1, const COMPLEX16Vector *in2)
Definition: VectorMultiply.c:218
XLALSSVectorMultiply
REAL4Vector * XLALSSVectorMultiply(REAL4Vector *out, const REAL4Vector *in1, const REAL4Vector *in2)
Definition: VectorMultiply.c:307
XLALCCVectorDivide
COMPLEX8Vector * XLALCCVectorDivide(COMPLEX8Vector *out, const COMPLEX8Vector *in1, const COMPLEX8Vector *in2)
Definition: VectorMultiply.c:68
XLALDZVectorMultiply
COMPLEX16Vector * XLALDZVectorMultiply(COMPLEX16Vector *out, const REAL8Vector *in1, const COMPLEX16Vector *in2)
Definition: VectorMultiply.c:277
LALZZVectorMultiplyConjugate
void LALZZVectorMultiplyConjugate(LALStatus *status, COMPLEX16Vector *out, const COMPLEX16Vector *in1, const COMPLEX16Vector *in2)
Definition: VectorMultiply.c:538
LALCCVectorMultiply
void LALCCVectorMultiply(LALStatus *status, COMPLEX8Vector *out, const COMPLEX8Vector *in1, const COMPLEX8Vector *in2)
UNDOCUMENTED.
Definition: VectorMultiply.c:442
XLALZZVectorMultiply
COMPLEX16Vector * XLALZZVectorMultiply(COMPLEX16Vector *out, const COMPLEX16Vector *in1, const COMPLEX16Vector *in2)
Definition: VectorMultiply.c:158
XLALCCVectorMultiplyConjugate
COMPLEX8Vector * XLALCCVectorMultiplyConjugate(COMPLEX8Vector *out, const COMPLEX8Vector *in1, const COMPLEX8Vector *in2)
Definition: VectorMultiply.c:188
LALDDVectorMultiply
void LALDDVectorMultiply(LALStatus *status, REAL8Vector *out, const REAL8Vector *in1, const REAL8Vector *in2)
Definition: VectorMultiply.c:666
VECTOROPSH_ESIZE
#define VECTOROPSH_ESIZE
Invalid input size.
Definition: VectorOps.h:52
VECTOROPSH_ENULL
#define VECTOROPSH_ENULL
Null pointer.
Definition: VectorOps.h:51
VECTOROPSH_ESZMM
#define VECTOROPSH_ESZMM
Size mismatch.
Definition: VectorOps.h:53
XLAL_ERROR_NULL
#define XLAL_ERROR_NULL(...)
Macro to invoke a failure from a XLAL routine returning a pointer.
Definition: XLALError.h:713
XLAL_EBADLEN
@ XLAL_EBADLEN
Inconsistent or invalid length.
Definition: XLALError.h:419
XLAL_EFAULT
@ XLAL_EFAULT
Invalid pointer.
Definition: XLALError.h:408
lal.git_version.status
string status
Definition: git_version.py:32
COMPLEX16Vector
Vector of type COMPLEX16, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:172
COMPLEX16Vector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:176
COMPLEX16Vector::data
COMPLEX16 * data
Pointer to the data array.
Definition: LALDatatypes.h:177
COMPLEX8Vector
Vector of type COMPLEX8, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:163
COMPLEX8Vector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:167
COMPLEX8Vector::data
COMPLEX8 * data
Pointer to the data array.
Definition: LALDatatypes.h:168
LALStatus
LAL status structure, see The LALStatus structure for more details.
Definition: LALDatatypes.h:947
REAL4Vector
Vector of type REAL4, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:145
REAL4Vector::data
REAL4 * data
Pointer to the data array.
Definition: LALDatatypes.h:150
REAL4Vector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:149
REAL8Vector
Vector of type REAL8, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:154
REAL8Vector::data
REAL8 * data
Pointer to the data array.
Definition: LALDatatypes.h:159
REAL8Vector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:158