ERIS Pipeline Reference Manual 1.8.10
eris_ifu_vector.c
1
2/*********************************************************************
3 * E.S.O. - VLT project
4 *
5 * "@(#) $Id: eris_ifu_vector.c,v 1.12 2013-07-31 10:35:34 aagudo Exp $"
6 *
7 * Functions that are implemented as recipes. They are also useedd in KMOS
8 * data reduction pipeline.
9 *
10 * who when what
11 * -------- ---------- ----------------------------------------------
12 */
13
14#ifdef HAVE_CONFIG_H
15#include <config.h>
16#endif
17
18/*------------------------------------------------------------------------------
19 * Includes, etc
20 *----------------------------------------------------------------------------*/
21#define _ISOC99_SOURCE
22
23#include <math.h>
24
25#include <cpl.h>
26
27#include "eris_ifu_error.h"
28#include "eris_ifu_vector.h"
29#include "eris_ifu_utils.h"
30//#include "eris_ifu_math.h"
31
32/* CPL_SORT_ASCENDING is introduced only after CPL 5.3.0 */
33#ifndef CPL_SORT_ASCENDING
34 #define CPL_SORT_ASCENDING 1
35#endif
36
37/*------------------------------------------------------------------------------
38 * Definitions
39 *----------------------------------------------------------------------------*/
56eris_ifu_vector* eris_ifu_vector_new(int n)
57{
58 eris_ifu_vector *ev = NULL;
59
60 cpl_ensure(n >= 1, CPL_ERROR_ILLEGAL_INPUT, NULL);
61
62 TRY
63 {
64 BRK_IF_NULL(
65 ev = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
66
67 BRK_IF_NULL(
68 ev->data = cpl_vector_new(n));
69
70 BRK_IF_ERROR(
71 cpl_vector_fill(ev->data, 0));
72
73 BRK_IF_NULL(
74 ev->mask = cpl_vector_new(n));
75
76 BRK_IF_ERROR(
77 cpl_vector_fill(ev->mask, 1));
78 }
79 CATCH
80 {
81 if (ev != NULL) {
82 cpl_vector_delete(ev->data); ev->data = NULL;
83 cpl_vector_delete(ev->mask); ev->mask = NULL;
84 }
85 cpl_free(ev); ev = NULL;
86 }
87
88 return ev;
89}
90
108eris_ifu_vector* eris_ifu_vector_new_wrap(int n, const double *data)
109{
110 eris_ifu_vector *ev = NULL;
111 cpl_vector *tmp = NULL;
112 double *pdata = NULL,
113 *pmask = NULL;
114
115 cpl_ensure(n >= 1, CPL_ERROR_ILLEGAL_INPUT, NULL);
116
117 TRY
118 {
119 BRK_IF_NULL(
120 ev = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
121
122 BRK_IF_NULL(
123 tmp = cpl_vector_wrap(n, (double*) data));
124 BRK_IF_NULL(
125 ev->data = cpl_vector_duplicate(tmp));
126 cpl_vector_unwrap(tmp);
127
128 BRK_IF_NULL(
129 ev->mask = cpl_vector_new(n));
130
131 BRK_IF_ERROR(
132 cpl_vector_fill(ev->mask, 1));
133
134 BRK_IF_NULL(
135 pdata = cpl_vector_get_data(ev->data));
136 BRK_IF_NULL(
137 pmask = cpl_vector_get_data(ev->mask));
138 for (int i = 0; i < n; i++) {
139 if (eris_ifu_is_nan_or_inf(pdata[i])) {
140 /*pdata[i] = NAN;*/
141 pmask[i] = 0.;
142 }
143 }
144 }
145 CATCH
146 {
147 if (ev != NULL) {
148 cpl_vector_delete(ev->data); ev->data = NULL;
149 cpl_vector_delete(ev->mask); ev->mask = NULL;
150 }
151 cpl_free(ev); ev = NULL;
152 }
153
154 return ev;
155}
156
175eris_ifu_vector* eris_ifu_vector_create(const cpl_vector *data)
176{
177 eris_ifu_vector *ev = NULL;
178 double *pdata = NULL,
179 *pmask = NULL;
180 int n = 0;
181
182 cpl_ensure(data, CPL_ERROR_NULL_INPUT, NULL);
183
184 TRY
185 {
186 BRK_IF_NULL(
187 ev = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
188
189 BRK_IF_NULL(
190 ev->data = cpl_vector_duplicate(data));
191
192 n = cpl_vector_get_size(data);
193
194 BRK_IF_NULL(
195 ev->mask = cpl_vector_new(n));
196
197 BRK_IF_ERROR(
198 cpl_vector_fill(ev->mask, 1));
199
200 BRK_IF_NULL(
201 pdata = cpl_vector_get_data(ev->data));
202 BRK_IF_NULL(
203 pmask = cpl_vector_get_data(ev->mask));
204 for (int i = 0; i < cpl_vector_get_size(data); i++)
205 {
206 if (eris_ifu_is_nan_or_inf(pdata[i])) {
207 /*pdata[i] = NAN;*/
208 pmask[i] = 0.;
209 }
210 }
211 }
212 CATCH
213 {
214 if (ev != NULL) {
215 cpl_vector_delete(ev->data); ev->data = NULL;
216 cpl_vector_delete(ev->mask); ev->mask = NULL;
217 }
218 cpl_free(ev); ev = NULL;
219 }
220
221 return ev;
222}
223
245eris_ifu_vector* eris_ifu_vector_create2(const cpl_vector *data,
246 const cpl_vector *mask)
247{
248 eris_ifu_vector *ev = NULL;
249 double *pdata = NULL,
250 *pmask = NULL;
251
252 cpl_ensure(data, CPL_ERROR_NULL_INPUT, NULL);
253 cpl_ensure(mask, CPL_ERROR_NULL_INPUT, NULL);
254 cpl_ensure(cpl_vector_get_size(data) == cpl_vector_get_size(mask),
255 CPL_ERROR_ILLEGAL_INPUT, NULL);
256
257 TRY
258 {
259 BRK_IF_NULL(
260 ev = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
261
262 BRK_IF_NULL(
263 ev->data = cpl_vector_duplicate(data));
264 BRK_IF_NULL(
265 ev->mask = cpl_vector_duplicate(mask));
266
267 BRK_IF_NULL(
268 pdata = cpl_vector_get_data(ev->data));
269 BRK_IF_NULL(
270 pmask = cpl_vector_get_data(ev->mask));
271
272 for (int i = 0; i < cpl_vector_get_size(data); i++)
273 {
274 if (eris_ifu_is_nan_or_inf(pmask[i])) {
275 /*pdata[i] = NAN;*/
276 pmask[i] = 0.;
277 } else if (pmask[i] >= 0.5) {
278 if (eris_ifu_is_nan_or_inf(pdata[i])) {
279 /*pdata[i] = NAN;*/
280 pmask[i] = 0.;
281 } else {
282 pmask[i] = 1;
283 }
284 } else {
285 /*pdata[i] = NAN;*/
286 pmask[i] = 0;
287 }
288 }
289 }
290 CATCH
291 {
292 if (ev != NULL) {
293 cpl_vector_delete(ev->data); ev->data = NULL;
294 cpl_vector_delete(ev->mask); ev->mask = NULL;
295 }
296 cpl_free(ev); ev = NULL;
297 }
298
299 return ev;
300}
301
310void eris_ifu_vector_delete(eris_ifu_vector *ev)
311{
312 TRY
313 {
314 if (ev != NULL) {
315 cpl_vector_delete(ev->data); ev->data = NULL;
316 cpl_vector_delete(ev->mask); ev->mask = NULL;
317 cpl_free(ev);
318 }
319 }
320 CATCH
321 {
322 }
323}
324
339eris_ifu_vector* eris_ifu_vector_duplicate(const eris_ifu_vector *ev)
340{
341 eris_ifu_vector *ev_dup = NULL;
342
343 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
344
345 TRY
346 {
347 BRK_IF_NULL(
348 ev_dup = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
349
350 ev_dup->data = cpl_vector_duplicate(ev->data);
351 CHECK_ERROR_STATE();
352
353 ev_dup->mask = cpl_vector_duplicate(ev->mask);
354 CHECK_ERROR_STATE();
355 }
356 CATCH
357 {
358 if (ev_dup != NULL) {
359 cpl_vector_delete(ev_dup->data); ev_dup->data = NULL;
360 cpl_vector_delete(ev_dup->mask); ev_dup->mask = NULL;
361 }
362 cpl_free(ev_dup); ev_dup = NULL;
363 }
364
365 return ev_dup;
366}
367
386cpl_error_code eris_ifu_vector_set(eris_ifu_vector *ev, int pos, double val)
387{
388 cpl_error_code err = CPL_ERROR_NONE;
389
390 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
391 cpl_ensure_code((pos >= 0) && (pos < cpl_vector_get_size(ev->data)),
392 CPL_ERROR_ACCESS_OUT_OF_RANGE);
393
394 TRY
395 {
396 cpl_vector_set(ev->data, pos, val);
397 if (eris_ifu_is_nan_or_inf(val)) {
398 cpl_vector_set(ev->mask, pos, 0.);
399 } else {
400 cpl_vector_set(ev->mask, pos, 1.);
401 }
402 }
403 CATCH
404 {
405 err = cpl_error_get_code();
406 }
407
408 return err;
409}
410
429double eris_ifu_vector_get_rej(const eris_ifu_vector *ev, int pos, int *rej)
430{
431 double ret = 0.;
432
433 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
434 cpl_ensure_code((pos >= 0) && (pos < cpl_vector_get_size(ev->data)),
435 CPL_ERROR_ACCESS_OUT_OF_RANGE);
436
437 TRY
438 {
439 ret = cpl_vector_get(ev->data, pos);
440 if (rej != NULL) {
441 if (cpl_vector_get(ev->mask, pos) > 0.5) {
442 /* value isn't rejected */
443 *rej = 0;
444 } else {
445 /* value is rejected */
446 *rej = 1;
447 }
448 }
449 }
450 CATCH
451 {
452 ret = 0.;
453 if (rej != NULL) {
454 *rej = -1;
455 }
456 }
457
458 return ret;
459}
460
478double eris_ifu_vector_get(const eris_ifu_vector *ev, int pos)
479{
480 int rej = 0;
481
482 return eris_ifu_vector_get_rej(ev, pos, &rej);
483}
484
501cpl_vector* eris_ifu_vector_get_mask(const eris_ifu_vector *ev)
502{
503 cpl_vector *mask = NULL;
504
505 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
506
507 TRY
508 {
509 BRK_IF_NULL(
510 mask = cpl_vector_duplicate(ev->mask));
511 }
512 CATCH
513 {
514 cpl_vector_delete(mask); mask = NULL;
515 }
516
517 return mask;
518}
519
535cpl_vector* eris_ifu_vector_get_data(const eris_ifu_vector *ev)
536{
537 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
538
539 cpl_vector *data = NULL;
540
541 TRY
542 {
543 BRK_IF_NULL(
544 data = cpl_vector_duplicate(ev->data));
545 for (int i = 0; i < eris_ifu_vector_get_size(ev); i++) {
546 if (eris_ifu_vector_is_rejected(ev, i)) {
547 BRK_IF_ERROR(
548 cpl_vector_set(data, i, NAN));
549 }
550 }
551 }
552 CATCH
553 {
554 cpl_vector_delete(data); data = NULL;
555 }
556 return data;
557}
558
575cpl_vector* eris_ifu_vector_get_bpm(eris_ifu_vector *ev)
576{
577 cpl_vector *mask = NULL;
578
579 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
580
581 TRY
582 {
583 BRK_IF_NULL(
584 mask = ev->mask);
585 }
586 CATCH
587 {
588 mask = NULL;
589 }
590
591 return mask;
592}
593
609cpl_error_code eris_ifu_vector_reject_from_mask(eris_ifu_vector *ev,
610 const cpl_vector *mask,
611 int keep)
612{
613 int ret = CPL_ERROR_NONE,
614 size = 0;
615 double *pkvmask = NULL;
616 const double *pmask = NULL;
617
618 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
619 cpl_ensure_code(mask, CPL_ERROR_NULL_INPUT);
620
621 size = cpl_vector_get_size(ev->data);
622
623 cpl_ensure_code(size == cpl_vector_get_size(mask), CPL_ERROR_ILLEGAL_INPUT);
624 cpl_ensure_code((keep == 0) || (keep == 1), CPL_ERROR_ILLEGAL_INPUT);
625
626 TRY
627 {
628 BRK_IF_NULL(
629 pkvmask = cpl_vector_get_data(ev->mask));
630 BRK_IF_NULL(
631 pmask = cpl_vector_get_data_const(mask));
632
633 for (int i = 0; i < size; i++) {
634 if ((!keep) ||
635 ((keep) && (pkvmask[i] > 0.5)))
636 {
637 pkvmask[i] = pmask[i];
638 }
639 }
640 CHECK_ERROR_STATE();
641 }
642 CATCH
643 {
644 ret = cpl_error_get_code();
645 }
646
647 return ret;
648}
649
662int eris_ifu_vector_count_rejected(const eris_ifu_vector *ev)
663{
664 int cnt = 0;
665 double *pmask = NULL;
666
667 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
668
669 TRY
670 {
671 BRK_IF_NULL(
672 pmask = cpl_vector_get_data(ev->mask));
673 for (int i = 0; i < cpl_vector_get_size(ev->mask); i++) {
674 if (pmask[i] == 0) {
675 cnt++;
676 }
677 }
678 }
679 CATCH
680 {
681 cnt = -1;
682 }
683
684 return cnt;
685}
686
699int eris_ifu_vector_count_non_rejected(const eris_ifu_vector *ev)
700{
701 int cnt = 0,
702 size = 0;
703 double *pmask = NULL;
704
705 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
706
707 TRY
708 {
709 size = cpl_vector_get_size(ev->data);
710
711 BRK_IF_NULL(
712 pmask = cpl_vector_get_data(ev->mask));
713 for (int i = 0; i < size; i++) {
714 if (pmask[i] == 0) {
715 cnt++;
716 }
717 }
718
719 cnt = size - cnt;
720 }
721 CATCH
722 {
723 cnt = -1;
724 }
725
726 return cnt;
727}
728
744int eris_ifu_vector_is_rejected(const eris_ifu_vector *ev, int n)
745{
746 int ret = 0;
747
748 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
749 cpl_ensure_code((n >= 0) && (n < cpl_vector_get_size(ev->data)),
750 CPL_ERROR_ACCESS_OUT_OF_RANGE);
751
752 TRY
753 {
754 if (cpl_vector_get(ev->mask, n) > 0.5) {
755 ret = FALSE;
756 } else {
757 ret = TRUE;
758 }
759 }
760 CATCH
761 {
762 ret = -1;
763 }
764
765 return ret;
766}
767
783cpl_error_code eris_ifu_vector_reject(eris_ifu_vector *ev, int n)
784{
785 int ret = CPL_ERROR_NONE;
786
787 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
788 cpl_ensure_code((n >= 0) && (n < cpl_vector_get_size(ev->data)),
789 CPL_ERROR_ILLEGAL_INPUT);
790
791 TRY
792 {
793/* cpl_vector_set(ev->data, n, NAN);*/
794 cpl_vector_set(ev->mask, n, 0);
795 CHECK_ERROR_STATE();
796 }
797 CATCH
798 {
799 ret = cpl_error_get_code();
800 }
801
802 return ret;
803}
804
822eris_ifu_vector* eris_ifu_vector_extract(const eris_ifu_vector *ev,
823 int istart,
824 int istop)
825{
826 eris_ifu_vector *ev_out = NULL;
827
828 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
829 cpl_ensure(istop > istart, CPL_ERROR_ILLEGAL_INPUT, NULL);
830
831 TRY
832 {
833 BRK_IF_NULL(
834 ev_out = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
835
836 BRK_IF_NULL(
837 ev_out->data = cpl_vector_extract(ev->data, istart, istop, 1));
838
839 BRK_IF_NULL(
840 ev_out->mask = cpl_vector_extract(ev->mask, istart, istop, 1));
841 }
842 CATCH
843 {
844 if (ev_out != NULL) {
845 cpl_vector_delete(ev_out->data); ev_out->data = NULL;
846 cpl_vector_delete(ev_out->mask); ev_out->mask = NULL;
847 }
848 cpl_free(ev_out); ev_out = NULL;
849 }
850
851 return ev_out;
852}
853
870cpl_vector* eris_ifu_vector_create_non_rejected(const eris_ifu_vector *ev)
871{
872 int cnt = 0,
873 j = 0,
874 n = 0;
875 const double *pkvmask = NULL,
876 *pkvdata = NULL;
877 double *pret = NULL;
878 cpl_vector *ret = NULL;
879
880 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
881
882 TRY
883 {
884 n = cpl_vector_get_size(ev->data);
885 cnt = eris_ifu_vector_count_rejected(ev);
886 CHECK_ERROR_STATE();
887
888 if (n-cnt > 0) {
889 BRK_IF_NULL(
890 ret = cpl_vector_new(n-cnt));
891 BRK_IF_NULL(
892 pret = cpl_vector_get_data(ret));
893 BRK_IF_NULL(
894 pkvdata = cpl_vector_get_data_const(ev->data));
895 BRK_IF_NULL(
896 pkvmask = cpl_vector_get_data_const(ev->mask));
897 for (int i = 0; i < n; i++) {
898 if (pkvmask[i] > 0.5) {
899 pret[j++] = pkvdata[i];
900 }
901 }
902 }
903 }
904 CATCH
905 {
906 cpl_vector_delete(ret); ret = NULL;
907 }
908
909 return ret;
910}
911
929cpl_error_code eris_ifu_vector_adapt_rejected(eris_ifu_vector *kv1,
930 eris_ifu_vector *kv2)
931{
932 cpl_error_code err = CPL_ERROR_NONE;
933 int size = 0;
934 double *pkv1mask = NULL,
935 *pkv2mask = NULL;
936
937 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
938 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
939
940 size = cpl_vector_get_size(kv1->data);
941
942 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
943 CPL_ERROR_ILLEGAL_INPUT);
944
945 TRY
946 {
947 BRK_IF_NULL(
948 pkv1mask = cpl_vector_get_data(kv1->mask));
949 BRK_IF_NULL(
950 pkv2mask = cpl_vector_get_data(kv2->mask));
951
952 for (int i = 0; i < size; i++) {
953 if (pkv1mask[i] < 0.5) {
954 pkv2mask[i] = 0.;
955 } else if (pkv2mask[i] < 0.5) {
956 pkv1mask[i] = 0.;
957 }
958 }
959 }
960 CATCH
961 {
962 err = cpl_error_get_code();
963 }
964
965 return err;
966}
967
986cpl_error_code eris_ifu_vector_add(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
987{
988 int size = 0;
989 double *pkv1data = NULL,
990 *pkv1mask = NULL,
991 *pkv2data = NULL,
992 *pkv2mask = NULL;
993 cpl_error_code err = CPL_ERROR_NONE;
994
995 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
996 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
997
998 size = cpl_vector_get_size(kv1->data);
999
1000 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1001 CPL_ERROR_ILLEGAL_INPUT);
1002
1003 TRY
1004 {
1005 BRK_IF_NULL(
1006 pkv1data = cpl_vector_get_data(kv1->data));
1007 BRK_IF_NULL(
1008 pkv1mask = cpl_vector_get_data(kv1->mask));
1009 BRK_IF_NULL(
1010 pkv2data = cpl_vector_get_data(kv2->data));
1011 BRK_IF_NULL(
1012 pkv2mask = cpl_vector_get_data(kv2->mask));
1013
1014 for (int i = 0; i < size; i++) {
1015 if ((pkv1mask[i] > 0.5) && (pkv2mask[i] > 0.5)) {
1016 /* add elements (if element in kv1 is rejected it stays anyway
1017 rejected) */
1018 pkv1data[i] += pkv2data[i];
1019
1020 if (eris_ifu_is_nan_or_inf(pkv1data[i])) {
1021 /*pkvdata[i] = NAN;*/
1022 pkv1mask[i] = 0.;
1023 }
1024 } else {
1025 /* element of kv2 is rejected, reject also element in kv1 */
1026 pkv1mask[i] = 0.;
1027 }
1028 }
1029 }
1030 CATCH
1031 {
1032 err = cpl_error_get_code();
1033 }
1034
1035 return err;
1036}
1037
1057cpl_error_code eris_ifu_vector_subtract(eris_ifu_vector *kv1,
1058 const eris_ifu_vector *kv2)
1059{
1060 int size = 0;
1061 double *pkv1data = NULL,
1062 *pkv1mask = NULL,
1063 *pkv2data = NULL,
1064 *pkv2mask = NULL;
1065 cpl_error_code err = CPL_ERROR_NONE;
1066
1067 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
1068 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
1069
1070 size = cpl_vector_get_size(kv1->data);
1071
1072 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1073 CPL_ERROR_ILLEGAL_INPUT);
1074
1075 TRY
1076 {
1077 BRK_IF_NULL(
1078 pkv1data = cpl_vector_get_data(kv1->data));
1079 BRK_IF_NULL(
1080 pkv1mask = cpl_vector_get_data(kv1->mask));
1081 BRK_IF_NULL(
1082 pkv2data = cpl_vector_get_data(kv2->data));
1083 BRK_IF_NULL(
1084 pkv2mask = cpl_vector_get_data(kv2->mask));
1085
1086 for (int i = 0; i < size; i++) {
1087 if ((pkv1mask[i] > 0.5) && (pkv2mask[i] > 0.5)) {
1088 /* subtract elements (if element in kv1 is rejected it stays anyway
1089 rejected) */
1090 pkv1data[i] -= pkv2data[i];
1091
1092 if (eris_ifu_is_nan_or_inf(pkv1data[i])) {
1093 /*pkvdata[i] = NAN;*/
1094 pkv1mask[i] = 0.;
1095 }
1096 } else {
1097 /* element of kv2 is rejected, reject also element in kv1 */
1098 pkv1mask[i] = 0.;
1099 }
1100 }
1101 }
1102 CATCH
1103 {
1104 err = cpl_error_get_code();
1105 }
1106
1107 return err;
1108}
1109
1128cpl_error_code eris_ifu_vector_multiply(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
1129{
1130 int size = 0;
1131 double *pkv1data = NULL,
1132 *pkv1mask = NULL,
1133 *pkv2data = NULL,
1134 *pkv2mask = NULL;
1135 cpl_error_code err = CPL_ERROR_NONE;
1136
1137 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
1138 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
1139
1140 size = cpl_vector_get_size(kv1->data);
1141
1142 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1143 CPL_ERROR_ILLEGAL_INPUT);
1144
1145 TRY
1146 {
1147
1148 BRK_IF_NULL(
1149 pkv1data = cpl_vector_get_data(kv1->data));
1150 BRK_IF_NULL(
1151 pkv1mask = cpl_vector_get_data(kv1->mask));
1152 BRK_IF_NULL(
1153 pkv2data = cpl_vector_get_data(kv2->data));
1154 BRK_IF_NULL(
1155 pkv2mask = cpl_vector_get_data(kv2->mask));
1156
1157 for (int i = 0; i < size; i++) {
1158 if ((pkv1mask[i] > 0.5) && (pkv2mask[i] > 0.5)) {
1159 /* multiply elements (if element in kv1 is rejected it stays anyway
1160 rejected) */
1161 pkv1data[i] *= pkv2data[i];
1162
1163 if (eris_ifu_is_nan_or_inf(pkv1data[i])) {
1164 /*pkvdata[i] = NAN;*/
1165 pkv1mask[i] = 0.;
1166 }
1167 } else {
1168 /* element of kv2 is rejected, reject also element in kv1 */
1169 pkv1mask[i] = 0.;
1170 }
1171 }
1172 }
1173 CATCH
1174 {
1175 err = cpl_error_get_code();
1176 }
1177
1178 return err;
1179}
1180
1201cpl_error_code eris_ifu_vector_divide(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
1202{
1203 int size = 0;
1204 double *pkv1data = NULL,
1205 *pkv1mask = NULL,
1206 *pkv2data = NULL,
1207 *pkv2mask = NULL;
1208 cpl_error_code err = CPL_ERROR_NONE;
1209
1210 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
1211 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
1212
1213 size = cpl_vector_get_size(kv1->data);
1214
1215 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1216 CPL_ERROR_ILLEGAL_INPUT);
1217
1218 TRY
1219 {
1220 BRK_IF_NULL(
1221 pkv1data = cpl_vector_get_data(kv1->data));
1222 BRK_IF_NULL(
1223 pkv1mask = cpl_vector_get_data(kv1->mask));
1224 BRK_IF_NULL(
1225 pkv2data = cpl_vector_get_data(kv2->data));
1226 BRK_IF_NULL(
1227 pkv2mask = cpl_vector_get_data(kv2->mask));
1228
1229 for (int i = 0; i < size; i++) {
1230 if ((pkv1mask[i] > 0.5) && (pkv2mask[i] > 0.5)) {
1231 /* divide elements (if element in kv1 is rejected it stays anyway
1232 rejected) */
1233 pkv1data[i] /= pkv2data[i];
1234
1235 if (eris_ifu_is_nan_or_inf(pkv1data[i])) {
1236 /*pkvdata[i] = NAN;*/
1237 pkv1mask[i] = 0.;
1238 }
1239 } else {
1240 /* element of kv2 is rejected, reject also element in kv1 */
1241 pkv1mask[i] = 0.;
1242 }
1243 }
1244 }
1245 CATCH
1246 {
1247 err = cpl_error_get_code();
1248 }
1249
1250 return err;
1251}
1252
1268cpl_error_code eris_ifu_vector_add_scalar(eris_ifu_vector *ev, double addend)
1269{
1270 int n = 0;
1271 double *pkvmask = NULL,
1272 *pkvdata = NULL;
1273 cpl_error_code err = CPL_ERROR_NONE;
1274
1275 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1276
1277 TRY
1278 {
1279 n = cpl_vector_get_size(ev->data);
1280 CHECK_ERROR_STATE();
1281
1282 BRK_IF_NULL(
1283 pkvdata = cpl_vector_get_data(ev->data));
1284 BRK_IF_NULL(
1285 pkvmask = cpl_vector_get_data(ev->mask));
1286 for (int i = 0; i < n; i++) {
1287 if (pkvmask[i] > 0.5) {
1288 pkvdata[i] += addend;
1289 }
1290 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1291 /*pkvdata[i] = NAN;*/
1292 pkvmask[i] = 0.;
1293 }
1294 }
1295 }
1296 CATCH
1297 {
1298 err = cpl_error_get_code();
1299 }
1300
1301 return err;
1302}
1303
1319cpl_error_code eris_ifu_vector_subtract_scalar(eris_ifu_vector *ev,
1320 double subtrahend)
1321{
1322 int n = 0;
1323 double *pkvmask = NULL,
1324 *pkvdata = NULL;
1325 cpl_error_code err = CPL_ERROR_NONE;
1326
1327 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1328
1329 TRY
1330 {
1331 n = cpl_vector_get_size(ev->data);
1332 CHECK_ERROR_STATE();
1333
1334 BRK_IF_NULL(
1335 pkvdata = cpl_vector_get_data(ev->data));
1336 BRK_IF_NULL(
1337 pkvmask = cpl_vector_get_data(ev->mask));
1338 for (int i = 0; i < n; i++) {
1339 if (pkvmask[i] > 0.5) {
1340 pkvdata[i] -= subtrahend;
1341 }
1342 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1343 /*pkvdata[i] = NAN;*/
1344 pkvmask[i] = 0.;
1345 }
1346 }
1347 }
1348 CATCH
1349 {
1350 err = cpl_error_get_code();
1351 }
1352
1353 return err;
1354}
1355
1371cpl_error_code eris_ifu_vector_multiply_scalar(eris_ifu_vector *ev, double factor)
1372{
1373 int n = 0;
1374 double *pkvmask = NULL,
1375 *pkvdata = NULL;
1376 cpl_error_code err = CPL_ERROR_NONE;
1377
1378 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1379
1380 TRY
1381 {
1382 n = cpl_vector_get_size(ev->data);
1383 CHECK_ERROR_STATE();
1384
1385 BRK_IF_NULL(
1386 pkvdata = cpl_vector_get_data(ev->data));
1387 BRK_IF_NULL(
1388 pkvmask = cpl_vector_get_data(ev->mask));
1389 for (int i = 0; i < n; i++) {
1390 if (pkvmask[i] > 0.5) {
1391 pkvdata[i] *= factor;
1392 }
1393 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1394 /*pkvdata[i] = NAN;*/
1395 pkvmask[i] = 0.;
1396 }
1397 }
1398 }
1399 CATCH
1400 {
1401 err = cpl_error_get_code();
1402 }
1403
1404 return err;
1405}
1406
1422cpl_error_code eris_ifu_vector_divide_scalar(eris_ifu_vector *ev, double dividend)
1423{
1424 int n = 0;
1425 double *pkvmask = NULL,
1426 *pkvdata = NULL;
1427 cpl_error_code err = CPL_ERROR_NONE;
1428
1429 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1430
1431 TRY
1432 {
1433 n = cpl_vector_get_size(ev->data);
1434 CHECK_ERROR_STATE();
1435
1436 BRK_IF_NULL(
1437 pkvdata = cpl_vector_get_data(ev->data));
1438 BRK_IF_NULL(
1439 pkvmask = cpl_vector_get_data(ev->mask));
1440 for (int i = 0; i < n; i++) {
1441 if (pkvmask[i] > 0.5) {
1442 pkvdata[i] /= dividend;
1443 }
1444 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1445 /*pkvdata[i] = NAN;*/
1446 pkvmask[i] = 0.;
1447 }
1448 }
1449 }
1450 CATCH
1451 {
1452 err = cpl_error_get_code();
1453 }
1454
1455 return err;
1456}
1457
1475cpl_error_code eris_ifu_vector_abs(eris_ifu_vector *ev)
1476{
1477 cpl_error_code ret_error = CPL_ERROR_NONE;
1478 double *pkvdata = NULL,
1479 *pkvmask = NULL;
1480
1481 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1482
1483 TRY
1484 {
1485 BRK_IF_NULL(
1486 pkvdata = cpl_vector_get_data(ev->data));
1487 BRK_IF_NULL(
1488 pkvmask = cpl_vector_get_data(ev->mask));
1489
1490 for (int i = 0; i < cpl_vector_get_size(ev->data);i++) {
1491 if ((pkvmask[i] > 0.5) && (pkvdata[i] < 0.0)) {
1492 pkvdata[i] = -pkvdata[i];
1493 }
1494 }
1495 }
1496 CATCH
1497 {
1498 ret_error = cpl_error_get_code();
1499 }
1500
1501 return ret_error;
1502}
1503
1516int eris_ifu_vector_get_size(const eris_ifu_vector *ev)
1517{
1518 int ret_val = 0;
1519
1520 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1521
1522 TRY
1523 {
1524 ret_val = cpl_vector_get_size(ev->data);
1525 CHECK_ERROR_STATE();
1526 }
1527 CATCH
1528 {
1529 ret_val = -1;
1530 }
1531
1532 return ret_val;
1533}
1534
1548double eris_ifu_vector_get_mean(const eris_ifu_vector *ev)
1549{
1550 cpl_vector *vec = NULL;
1551 double val = 0.;
1552
1553 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1554
1555 TRY
1556 {
1557 vec = eris_ifu_vector_create_non_rejected(ev);
1558 if (vec != NULL) {
1559 val = cpl_vector_get_mean(vec);
1560 CHECK_ERROR_STATE();
1561 }
1562 }
1563 CATCH
1564 {
1565 val = 0.;
1566 }
1567 cpl_vector_delete(vec); vec = NULL;
1568
1569 return val;
1570}
1571
1593double eris_ifu_vector_get_median(const eris_ifu_vector *ev,
1594 const enum medianType type)
1595{
1596 cpl_vector *vec = NULL;
1597 double val = 0.;
1598 int size = 0;
1599
1600 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1601
1602 TRY
1603 {
1604 vec = eris_ifu_vector_create_non_rejected(ev);
1605
1606 if (vec != NULL) {
1607 size = cpl_vector_get_size(vec);
1608 if ((type == ERIS_IFU_STATISTICAL) && ((size % 2) == 0)) {
1609 /* statistical method and even size */
1610 cpl_vector_sort(vec, CPL_SORT_ASCENDING);
1611
1612 val = cpl_vector_get(vec, size/2 - 1);
1613 } else {
1614 /* arithmetic method or uneven size */
1615 val = cpl_vector_get_median(vec);
1616 }
1617 }
1618 }
1619 CATCH
1620 {
1621 val = 0.;
1622 }
1623 cpl_vector_delete(vec); vec = NULL;
1624
1625 return val;
1626}
1627
1640eris_ifu_vector* eris_ifu_vector_cut_percentian(const eris_ifu_vector *ev,
1641 double percentage)
1642{
1643 eris_ifu_vector *ret_vec = NULL;
1644 cpl_vector *vec = NULL,
1645 *cut_vec = NULL;
1646 int size = 0;
1647
1648 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
1649 cpl_ensure((percentage >= 0.0) && (percentage < 1.0),
1650 CPL_ERROR_ILLEGAL_INPUT, NULL);
1651
1652 TRY
1653 {
1654 vec = eris_ifu_vector_create_non_rejected(ev);
1655
1656 if (vec != NULL) {
1657 /* sort vector */
1658 cpl_vector_sort(vec, CPL_SORT_ASCENDING);
1659 CHECK_ERROR_STATE();
1660
1661 /* cut percentage wanted */
1662 size = cpl_vector_get_size(vec);
1663 cpl_size tmp = (cpl_size)rint((1.-percentage)*(double)size-1.);
1664 BRK_IF_NULL(
1665 cut_vec = cpl_vector_extract(vec, 0, tmp, 1));
1666 BRK_IF_NULL(
1667 ret_vec = eris_ifu_vector_create(cut_vec));
1668 cpl_vector_delete(cut_vec);
1669 }
1670 }
1671 CATCH
1672 {
1673 eris_ifu_vector_delete(ret_vec); ret_vec = NULL;
1674 }
1675 cpl_vector_delete(vec); vec = NULL;
1676
1677 return ret_vec;
1678}
1679
1693double eris_ifu_vector_get_sum(const eris_ifu_vector *ev)
1694{
1695 int n = 0;
1696 double sum = 0,
1697 *pkvmask = NULL,
1698 *pkvdata = NULL;
1699
1700 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1701
1702 TRY
1703 {
1704 n = cpl_vector_get_size(ev->data);
1705 CHECK_ERROR_STATE();
1706
1707 BRK_IF_NULL(
1708 pkvdata = cpl_vector_get_data(ev->data));
1709 BRK_IF_NULL(
1710 pkvmask = cpl_vector_get_data(ev->mask));
1711 for (int i = 0; i < n; i++) {
1712 if (pkvmask[i] > 0.5) {
1713 sum += pkvdata[i];
1714 }
1715 }
1716 }
1717 CATCH
1718 {
1719 sum = 0;
1720 }
1721
1722 return sum;
1723}
1724
1743double eris_ifu_vector_get_stdev(const eris_ifu_vector *ev)
1744{
1745 cpl_vector *vec = NULL;
1746 double val = 0.;
1747
1748 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1749
1750 TRY
1751 {
1752 vec = eris_ifu_vector_create_non_rejected(ev);
1753 if (vec != NULL) {
1754 val = cpl_vector_get_stdev(vec);
1755 CHECK_ERROR_STATE();
1756 }
1757 }
1758 CATCH
1759 {
1760 val = -1.;
1761 }
1762 cpl_vector_delete(vec); vec = NULL;
1763
1764 return val;
1765}
1766
1785double eris_ifu_vector_get_stdev_median(const eris_ifu_vector *ev)
1786{
1787 int n = 0;
1788 double stdev = 0,
1789 median = 0,
1790 *pkvmask = NULL,
1791 *pkvdata = NULL;
1792
1793 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1794
1795 TRY
1796 {
1797 n = eris_ifu_vector_count_non_rejected(ev);
1798 CHECK_ERROR_STATE();
1799
1800 if (n <= 1) {
1801 BRK_WITH_ERROR(CPL_ERROR_ILLEGAL_INPUT);
1802 }
1803
1804 median = eris_ifu_vector_get_median(ev, ERIS_IFU_ARITHMETIC);
1805 CHECK_ERROR_STATE();
1806
1807 BRK_IF_NULL(
1808 pkvdata = cpl_vector_get_data(ev->data));
1809 BRK_IF_NULL(
1810 pkvmask = cpl_vector_get_data(ev->mask));
1811 for (int i = 0; i < cpl_vector_get_size(ev->data); i++) {
1812 if (pkvmask[i] > 0.5) {
1813 stdev += pow(pkvdata[i]-median, 2);
1814 }
1815 }
1816
1817 stdev /= (n - 1);
1818 stdev = sqrt(stdev);
1819 }
1820 CATCH
1821 {
1822 stdev = -1;
1823 }
1824
1825 return stdev;
1826}
1827
1842double eris_ifu_vector_get_max(const eris_ifu_vector *ev, int *pos)
1843{
1844 double val = -DBL_MAX;
1845 const double *pkvdata = NULL,
1846 *pkvmask = NULL;
1847 int n = 0;
1848
1849 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1850
1851 TRY
1852 {
1853 BRK_IF_NULL(
1854 pkvdata = cpl_vector_get_data_const(ev->data));
1855 BRK_IF_NULL(
1856 pkvmask = cpl_vector_get_data_const(ev->mask));
1857
1858 n = cpl_vector_get_size(ev->data);
1859 if (eris_ifu_vector_count_rejected(ev) == n) {
1860 val = 0.;
1861 if (pos != NULL) {
1862 *pos = -1;
1863 }
1864 } else {
1865 for (int i = 0; i < n; i++) {
1866 if ((pkvmask[i] > 0.5) && (val < pkvdata[i])) {
1867 val = pkvdata[i];
1868 if (pos != NULL) {
1869 *pos = i;
1870 }
1871 }
1872 }
1873 }
1874 CHECK_ERROR_STATE();
1875 }
1876 CATCH
1877 {
1878 val = 0.;
1879 if (pos != NULL) {
1880 *pos = -1;
1881 }
1882 }
1883
1884 return val;
1885}
1886
1901double eris_ifu_vector_get_min(const eris_ifu_vector *ev, int *pos)
1902{
1903 double val = DBL_MAX;
1904 const double *pkvdata = NULL,
1905 *pkvmask = NULL;
1906 int n = 0;
1907
1908 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1909
1910 TRY
1911 {
1912 BRK_IF_NULL(
1913 pkvdata = cpl_vector_get_data_const(ev->data));
1914 BRK_IF_NULL(
1915 pkvmask = cpl_vector_get_data_const(ev->mask));
1916
1917 n = cpl_vector_get_size(ev->data);
1918 if (eris_ifu_vector_count_rejected(ev) == n) {
1919 val = 0.;
1920 if (pos != NULL) {
1921 *pos = -1;
1922 }
1923 } else {
1924 for (int i = 0; i < n; i++) {
1925 if ((pkvmask[i] > 0.5) && (val > pkvdata[i])) {
1926 val = pkvdata[i];
1927 if (pos != NULL) {
1928 *pos = i;
1929 }
1930 }
1931 }
1932 }
1933 CHECK_ERROR_STATE();
1934 }
1935 CATCH
1936 {
1937 val = 0.;
1938 if (pos != NULL) {
1939 *pos = -1;
1940 }
1941 }
1942
1943 return val;
1944}
1945
1963cpl_error_code eris_ifu_vector_power(eris_ifu_vector *ev, double exponent)
1964{
1965 int n = 0;
1966 double *pkvmask = NULL,
1967 *pkvdata = NULL;
1968 cpl_error_code err = CPL_ERROR_NONE;
1969
1970 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1971
1972 TRY
1973 {
1974 if (exponent == 0.0) {
1975 /* create vector filled with ones */
1976 eris_ifu_vector_multiply_scalar(ev, 0.0);
1977 CHECK_ERROR_STATE();
1978
1979 eris_ifu_vector_add_scalar(ev, 1.0);
1980 CHECK_ERROR_STATE();
1981 } else {
1982 n = cpl_vector_get_size(ev->data);
1983 CHECK_ERROR_STATE();
1984
1985 BRK_IF_NULL(
1986 pkvdata = cpl_vector_get_data(ev->data));
1987 BRK_IF_NULL(
1988 pkvmask = cpl_vector_get_data(ev->mask));
1989 for (int i = 0; i < n; i++) {
1990 if (pkvmask[i] > 0.5) {
1991 pkvdata[i] = pow(pkvdata[i], exponent);
1992 }
1993 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1994 /*pkvdata[i] = NAN;*/
1995 pkvmask[i] = 0.;
1996 }
1997 }
1998 }
1999 }
2000 CATCH
2001 {
2002 err = cpl_error_get_code();
2003 }
2004
2005 return err;
2006}
2007
2025cpl_error_code eris_ifu_vector_fill(eris_ifu_vector *ev, double val)
2026{
2027 cpl_error_code err = CPL_ERROR_NONE;
2028
2029 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2030
2031 TRY
2032 {
2033 for (int i = 0; i < eris_ifu_vector_get_size(ev); i++) {
2034 eris_ifu_vector_set(ev, i, val);
2035 }
2036 }
2037 CATCH
2038 {
2039 err = cpl_error_get_code();
2040 }
2041
2042 return err;
2043}
2044
2061cpl_error_code eris_ifu_vector_flip(eris_ifu_vector* ev)
2062{
2063 cpl_error_code ret_error = CPL_ERROR_NONE;
2064 double *pkvdata = NULL,
2065 *pkvmask = NULL,
2066 tmp_dbl = 0;
2067 int half_size = 0,
2068 size = 0;
2069
2070 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2071
2072 TRY
2073 {
2074 BRK_IF_NULL(
2075 pkvdata = cpl_vector_get_data(ev->data));
2076 BRK_IF_NULL(
2077 pkvmask = cpl_vector_get_data(ev->mask));
2078
2079 size = cpl_vector_get_size(ev->data);
2080 half_size = floor(size / 2);
2081
2082 for (int i = 0; i < half_size;i++) {
2083 tmp_dbl = pkvdata[i];
2084 pkvdata[i] = pkvdata[size-1-i];
2085 pkvdata[size-1-i] = tmp_dbl;
2086
2087 tmp_dbl = pkvmask[i];
2088 pkvmask[i] = pkvmask[size-1-i];
2089 pkvmask[size-1-i] = tmp_dbl;
2090 }
2091 }
2092 CATCH
2093 {
2094 ret_error = cpl_error_get_code();
2095 }
2096
2097 return ret_error;
2098}
2099
2120eris_ifu_vector* eris_ifu_vector_histogram(const eris_ifu_vector *ev, int nbins)
2121{
2122 int pos = 0;
2123 const double *pkvdata = NULL,
2124 *pkvmask = NULL;
2125 double *phdata = NULL,
2126 binwidth = 0.0,
2127 hmin = 0.0,
2128 hmax = 0.0;
2129 eris_ifu_vector *h = NULL;
2130
2131 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
2132 cpl_ensure(nbins > 0, CPL_ERROR_NULL_INPUT, NULL);
2133
2134 TRY
2135 {
2136 hmin = eris_ifu_vector_get_min(ev, NULL);
2137 hmax = eris_ifu_vector_get_max(ev, NULL);
2138 CHECK_ERROR_STATE();
2139
2140 binwidth = (hmax - hmin) / (nbins - 1);
2141
2142 BRK_IF_NULL(
2143 pkvdata = cpl_vector_get_data_const(ev->data));
2144 BRK_IF_NULL(
2145 pkvmask = cpl_vector_get_data_const(ev->mask));
2146
2147 BRK_IF_NULL(
2148 h = eris_ifu_vector_new(nbins));
2149 BRK_IF_NULL(
2150 phdata = cpl_vector_get_data(h->data));
2151
2152 for (int i = 0; i < cpl_vector_get_size(ev->data); i++) {
2153 if (pkvmask[i] > 0.5) {
2154 pos = floor((pkvdata[i] - hmin) / binwidth);
2155 phdata[pos]++;
2156 }
2157 }
2158 }
2159 CATCH
2160 {
2161 eris_ifu_vector_delete(h); h = NULL;
2162 }
2163
2164 return h;
2165}
2166
2181eris_ifu_vector* eris_ifu_vector_load(const char *filename, int position)
2182{
2183 cpl_vector *vec = NULL;
2184 eris_ifu_vector *ev = NULL;
2185
2186 TRY
2187 {
2188 vec = cpl_vector_load(filename, position);
2189 if (cpl_error_get_code() != CPL_ERROR_NONE) {
2190 if (cpl_error_get_code() == CPL_ERROR_FILE_IO) {
2191 cpl_msg_error("", "File not found: %s", filename);
2192 } else {
2193 cpl_msg_error("", "Problem loading file '%s' (%s --> Code %d)",
2194 filename, cpl_error_get_message(),
2195 cpl_error_get_code());
2196 }
2197 }
2198 CHECK_ERROR_STATE();
2199
2200 BRK_IF_NULL(
2201 ev = eris_ifu_vector_create(vec));
2202 cpl_vector_delete(vec);
2203 }
2204 CATCH
2205 {
2206 eris_ifu_vector_delete(ev);
2207 }
2208
2209 return ev;
2210}
2211
2231cpl_error_code eris_ifu_vector_save(const eris_ifu_vector *ev,
2232 const char *filename,
2233 cpl_type_bpp bpp,
2234 const cpl_propertylist *pl,
2235 unsigned mode,
2236 double rej_val)
2237{
2238 cpl_error_code err = CPL_ERROR_NONE;
2239 eris_ifu_vector *ev_dup = NULL;
2240 double *pkvdata = NULL,
2241 *pkvmask = NULL;
2242 int n = 0;
2243
2244 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2245
2246 TRY
2247 {
2248 if ((rej_val != -1) || (eris_ifu_is_nan_or_inf(rej_val))) {
2249 BRK_IF_NULL(
2250 ev_dup = eris_ifu_vector_duplicate(ev));
2251 /* set rejected values to NaN */
2252 BRK_IF_NULL(
2253 pkvdata = cpl_vector_get_data(ev_dup->data));
2254 BRK_IF_NULL(
2255 pkvmask = cpl_vector_get_data(ev_dup->mask));
2256 n = cpl_vector_get_size(ev_dup->data);
2257 for (int i = 0; i < n; i++) {
2258 if (pkvmask[i] < 0.5) {
2259 pkvdata[i] = rej_val;
2260 }
2261 }
2262
2263 err = cpl_vector_save(ev_dup->data, filename, bpp, pl, mode);
2264 CHECK_ERROR_STATE();
2265 } else {
2266 err = cpl_vector_save(ev->data, filename, bpp, pl, mode);
2267 CHECK_ERROR_STATE();
2268 }
2269 eris_ifu_vector_delete(ev_dup); ev_dup = NULL;
2270 }
2271 CATCH
2272 {
2273 err = cpl_error_get_code();
2274 }
2275
2276 return err;
2277}
2278
2289cpl_error_code eris_ifu_vector_dump(const eris_ifu_vector *ev)
2290{
2291 int n = 0;
2292 cpl_error_code err = CPL_ERROR_NONE;
2293 const double *pkvdata = NULL,
2294 *pkvmask = NULL;
2295
2296 TRY
2297 {
2298 if (ev == NULL) {
2299 cpl_msg_debug("", " ====== START KMCLIPM_VECTOR ======");
2300 cpl_msg_debug("", " empty vector");
2301 cpl_msg_debug("", " ====== END KMCLIPM_VECTOR ========");
2302 } else {
2303 n = cpl_vector_get_size(ev->data);
2304
2305 if (n != cpl_vector_get_size(ev->mask)) {
2306 BRK_WITH_ERROR_MSG(CPL_ERROR_ILLEGAL_INPUT,
2307 "data and mask not of same size!");
2308 }
2309
2310 BRK_IF_NULL(
2311 pkvdata = cpl_vector_get_data_const(ev->data));
2312 BRK_IF_NULL(
2313 pkvmask = cpl_vector_get_data_const(ev->mask));
2314
2315 cpl_msg_debug("", " ====== START KMCLIPM_VECTOR ======");
2316 cpl_msg_debug("", " #\tdata:\tmask:");
2317 cpl_msg_debug("", " ---------------------");
2318 for (int i = 0; i < n; i++) {
2319 cpl_msg_debug("", " %d\t%g\t%g", i, pkvdata[i], pkvmask[i]);
2320 }
2321 cpl_msg_debug("", " ====== END KMCLIPM_VECTOR ========");
2322 CHECK_ERROR_STATE();
2323 }
2324 }
2325 CATCH
2326 {
2327 err = cpl_error_get_code();
2328 }
2329
2330 return err;
2331}
2332
2341int eris_ifu_is_nan_or_inf(double A)
2342{
2343 return (isnan(A) || (isinf(A)==1) || (isinf(A)==-1));
2344}
2345
2354cpl_error_code eris_ifu_vector_sqrt(eris_ifu_vector *ev)
2355{
2356 cpl_size n = 0;
2357 double *pkvmask = NULL,
2358 *pkvdata = NULL;
2359 cpl_error_code err = CPL_ERROR_NONE;
2360
2361 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2362
2363 TRY
2364 {
2365 n = cpl_vector_get_size(ev->data);
2366 CHECK_ERROR_STATE();
2367
2368 BRK_IF_NULL(
2369 pkvdata = cpl_vector_get_data(ev->data));
2370 BRK_IF_NULL(
2371 pkvmask = cpl_vector_get_data(ev->mask));
2372
2373 /* Compute the sqrt */
2374 for (int i = 0; i < n; i++) {
2375 if (pkvmask[i] > 0.5) {
2376 /* assert that data is >= 0
2377 it can be NaN, since sqrt() handles NaN correctly:
2378 sqrt(NaN) = NaN */
2379 cpl_ensure_code(pkvdata[i] >= 0, CPL_ERROR_ILLEGAL_INPUT);
2380
2381 pkvdata[i] = sqrt(pkvdata[i]);
2382
2383 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
2384 /*pkvdata[i] = NAN;*/
2385 pkvmask[i] = 0.;
2386 }
2387 }
2388 }
2389 }
2390 CATCH
2391 {
2392 err = cpl_error_get_code();
2393 }
2394
2395 return err;
2396}
BRK_WITH_ERROR
#define BRK_WITH_ERROR(code)
Set a new CPL error, and exit the try-block.
Definition: eris_ifu_error.h:306
BRK_IF_ERROR
#define BRK_IF_ERROR(function)
If function is or returns an error != CPL_ERROR_NONE, then the try-block is exited.
Definition: eris_ifu_error.h:339
CHECK_ERROR_STATE
#define CHECK_ERROR_STATE(void)
Check the CPL error state, and exit the try-block if not CPL_ERROR_NONE.
Definition: eris_ifu_error.h:266
BRK_WITH_ERROR_MSG
#define BRK_WITH_ERROR_MSG(code,...)
Set a new CPL error, and exit the try-block.
Definition: eris_ifu_error.h:322
TRY
#define TRY
Beginning of a TRY-block.
Definition: eris_ifu_error.h:156
CATCH
#define CATCH
End of a TRY-block, beginning of a CATCH-block.
Definition: eris_ifu_error.h:173
BRK_IF_NULL
#define BRK_IF_NULL(function)
If function is or returns a NULL pointer, then the try-block is exited.
Definition: eris_ifu_error.h:360
eris_ifu_vector_flip
cpl_error_code eris_ifu_vector_flip(eris_ifu_vector *ev)
Flip the values of a vector.
Definition: eris_ifu_vector.c:2061
eris_ifu_vector_get_size
int eris_ifu_vector_get_size(const eris_ifu_vector *ev)
Get the size of the eris_ifu_vector.
Definition: eris_ifu_vector.c:1516
eris_ifu_vector_create2
eris_ifu_vector * eris_ifu_vector_create2(const cpl_vector *data, const cpl_vector *mask)
Create a new eris_ifu_vector out of a data and mask cpl_vector.
Definition: eris_ifu_vector.c:245
eris_ifu_vector_histogram
eris_ifu_vector * eris_ifu_vector_histogram(const eris_ifu_vector *ev, int nbins)
Calculates the histogram of a vector.
Definition: eris_ifu_vector.c:2120
eris_ifu_vector_get_max
double eris_ifu_vector_get_max(const eris_ifu_vector *ev, int *pos)
Get the maximum of the eris_ifu_vector and its position.
Definition: eris_ifu_vector.c:1842
eris_ifu_vector_get_stdev_median
double eris_ifu_vector_get_stdev_median(const eris_ifu_vector *ev)
Compute the bias-corrected standard deviation of a vectors elements using median.
Definition: eris_ifu_vector.c:1785
eris_ifu_is_nan_or_inf
int eris_ifu_is_nan_or_inf(double A)
Checks if a value is nan, inf or -inf.
Definition: eris_ifu_vector.c:2341
eris_ifu_vector_new
eris_ifu_vector * eris_ifu_vector_new(int n)
Create a new eris_ifu_vector.
Definition: eris_ifu_vector.c:56
eris_ifu_vector_get_sum
double eris_ifu_vector_get_sum(const eris_ifu_vector *ev)
Compute the sum of non-rejected eris_ifu_vector elements.
Definition: eris_ifu_vector.c:1693
eris_ifu_vector_extract
eris_ifu_vector * eris_ifu_vector_extract(const eris_ifu_vector *ev, int istart, int istop)
Extract a sub_vector from a eris_ifu_vector.
Definition: eris_ifu_vector.c:822
eris_ifu_vector_get_data
cpl_vector * eris_ifu_vector_get_data(const eris_ifu_vector *ev)
Get a copy of the data, rejected values are set to NaN.
Definition: eris_ifu_vector.c:535
eris_ifu_vector_divide_scalar
cpl_error_code eris_ifu_vector_divide_scalar(eris_ifu_vector *ev, double dividend)
Elementwise division of a eris_ifu_vector and a scalar.
Definition: eris_ifu_vector.c:1422
eris_ifu_vector_subtract
cpl_error_code eris_ifu_vector_subtract(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
Subtract two eris_ifu_vectors.
Definition: eris_ifu_vector.c:1057
eris_ifu_vector_abs
cpl_error_code eris_ifu_vector_abs(eris_ifu_vector *ev)
Calculates the absolute of an vector inplace.
Definition: eris_ifu_vector.c:1475
eris_ifu_vector_multiply
cpl_error_code eris_ifu_vector_multiply(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
Multiply two eris_ifu_vectors.
Definition: eris_ifu_vector.c:1128
eris_ifu_vector_save
cpl_error_code eris_ifu_vector_save(const eris_ifu_vector *ev, const char *filename, cpl_type_bpp bpp, const cpl_propertylist *pl, unsigned mode, double rej_val)
Override for cpl_vector_save().
Definition: eris_ifu_vector.c:2231
eris_ifu_vector_get_stdev
double eris_ifu_vector_get_stdev(const eris_ifu_vector *ev)
Compute the bias-corrected standard deviation of a vectors elements.
Definition: eris_ifu_vector.c:1743
eris_ifu_vector_cut_percentian
eris_ifu_vector * eris_ifu_vector_cut_percentian(const eris_ifu_vector *ev, double percentage)
Remove a certain percentage of brightest pixels.
Definition: eris_ifu_vector.c:1640
eris_ifu_vector_is_rejected
int eris_ifu_vector_is_rejected(const eris_ifu_vector *ev, int n)
Test if a value is good or bad.
Definition: eris_ifu_vector.c:744
eris_ifu_vector_new_wrap
eris_ifu_vector * eris_ifu_vector_new_wrap(int n, const double *data)
Create a new eris_ifu_vector from a vector (duplicated).
Definition: eris_ifu_vector.c:108
eris_ifu_vector_subtract_scalar
cpl_error_code eris_ifu_vector_subtract_scalar(eris_ifu_vector *ev, double subtrahend)
Elementwise subtraction of a scalar from a eris_ifu_vector.
Definition: eris_ifu_vector.c:1319
eris_ifu_vector_get_mean
double eris_ifu_vector_get_mean(const eris_ifu_vector *ev)
Compute the mean value of non-rejected eris_ifu_vector elements.
Definition: eris_ifu_vector.c:1548
eris_ifu_vector_sqrt
cpl_error_code eris_ifu_vector_sqrt(eris_ifu_vector *ev)
eris_ifu_vector_sqrt
Definition: eris_ifu_vector.c:2354
eris_ifu_vector_get_mask
cpl_vector * eris_ifu_vector_get_mask(const eris_ifu_vector *ev)
Get a copy of the mask of eris_ifu_vector.
Definition: eris_ifu_vector.c:501
eris_ifu_vector_duplicate
eris_ifu_vector * eris_ifu_vector_duplicate(const eris_ifu_vector *ev)
This function duplicates an existing eris_ifu_vector and allocates memory.
Definition: eris_ifu_vector.c:339
eris_ifu_vector_reject_from_mask
cpl_error_code eris_ifu_vector_reject_from_mask(eris_ifu_vector *ev, const cpl_vector *mask, int keep)
Set the rejected elements in an eris_ifu_vector as defined in a mask.
Definition: eris_ifu_vector.c:609
eris_ifu_vector_fill
cpl_error_code eris_ifu_vector_fill(eris_ifu_vector *ev, double val)
Fill a eris_ifu_vector.
Definition: eris_ifu_vector.c:2025
eris_ifu_vector_multiply_scalar
cpl_error_code eris_ifu_vector_multiply_scalar(eris_ifu_vector *ev, double factor)
Elementwise multiplication of a scalar to a eris_ifu_vector.
Definition: eris_ifu_vector.c:1371
eris_ifu_vector_adapt_rejected
cpl_error_code eris_ifu_vector_adapt_rejected(eris_ifu_vector *kv1, eris_ifu_vector *kv2)
Assert that rejected values on both vectors are the same.
Definition: eris_ifu_vector.c:929
medianType
medianType
The type of median behavior: For an odd number of samples the behaviour is the same for both methods....
Definition: eris_ifu_vector.h:58
eris_ifu_vector_get_bpm
cpl_vector * eris_ifu_vector_get_bpm(eris_ifu_vector *ev)
Get the pointer to the mask of the eris_ifu_vector.
Definition: eris_ifu_vector.c:575
eris_ifu_vector_count_non_rejected
int eris_ifu_vector_count_non_rejected(const eris_ifu_vector *ev)
Count the number of non-rejected elements in a eris_ifu_vector.
Definition: eris_ifu_vector.c:699
eris_ifu_vector_set
cpl_error_code eris_ifu_vector_set(eris_ifu_vector *ev, int pos, double val)
Set an element of the eris_ifu_vector.
Definition: eris_ifu_vector.c:386
eris_ifu_vector_get
double eris_ifu_vector_get(const eris_ifu_vector *ev, int pos)
Get an element of the eris_ifu_vector.
Definition: eris_ifu_vector.c:478
eris_ifu_vector_get_rej
double eris_ifu_vector_get_rej(const eris_ifu_vector *ev, int pos, int *rej)
Get an element of the eris_ifu_vector.
Definition: eris_ifu_vector.c:429
eris_ifu_vector_add
cpl_error_code eris_ifu_vector_add(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
Add a eris_ifu_vector to another.
Definition: eris_ifu_vector.c:986
eris_ifu_vector_delete
void eris_ifu_vector_delete(eris_ifu_vector *ev)
Delete a eris_ifu_vector.
Definition: eris_ifu_vector.c:310
eris_ifu_vector_count_rejected
int eris_ifu_vector_count_rejected(const eris_ifu_vector *ev)
Count the number of rejected elements in a eris_ifu_vector.
Definition: eris_ifu_vector.c:662
eris_ifu_vector_power
cpl_error_code eris_ifu_vector_power(eris_ifu_vector *ev, double exponent)
Compute the elementwise power of the vector.
Definition: eris_ifu_vector.c:1963
eris_ifu_vector_get_min
double eris_ifu_vector_get_min(const eris_ifu_vector *ev, int *pos)
Get the minimum of the eris_ifu_vector and its position.
Definition: eris_ifu_vector.c:1901
eris_ifu_vector_load
eris_ifu_vector * eris_ifu_vector_load(const char *filename, int position)
Override for cpl_vector_load().
Definition: eris_ifu_vector.c:2181
eris_ifu_vector_dump
cpl_error_code eris_ifu_vector_dump(const eris_ifu_vector *ev)
All values contained in vec are printed for debugging purposes.
Definition: eris_ifu_vector.c:2289
eris_ifu_vector_create_non_rejected
cpl_vector * eris_ifu_vector_create_non_rejected(const eris_ifu_vector *ev)
Creates a cpl_vector out of a eris_ifu_vector with non-rejected values.
Definition: eris_ifu_vector.c:870
eris_ifu_vector_add_scalar
cpl_error_code eris_ifu_vector_add_scalar(eris_ifu_vector *ev, double addend)
Elementwise addition of a scalar to a eris_ifu_vector.
Definition: eris_ifu_vector.c:1268
eris_ifu_vector_create
eris_ifu_vector * eris_ifu_vector_create(const cpl_vector *data)
Create a new eris_ifu_vector out of a data cpl_vector.
Definition: eris_ifu_vector.c:175
eris_ifu_vector_divide
cpl_error_code eris_ifu_vector_divide(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
Divide two eris_ifu_vectors element-wise.
Definition: eris_ifu_vector.c:1201
eris_ifu_vector_reject
cpl_error_code eris_ifu_vector_reject(eris_ifu_vector *ev, int n)
Set a value as rejected in a eris_ifu_vector.
Definition: eris_ifu_vector.c:783
eris_ifu_vector_get_median
double eris_ifu_vector_get_median(const eris_ifu_vector *ev, const enum medianType type)
Compute the median of the elements of a vector.
Definition: eris_ifu_vector.c:1593
Generated on Fri Sep 19 2025 20:45:26 for ERIS Pipeline Reference Manual by doxygen 1.9.6