00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #ifdef HAVE_CONFIG_H
00026 #include <config.h>
00027 #endif
00028
00029 #include <list_void.h>
00030
00031 #include <math.h>
00032 #include <stdbool.h>
00033 #include <stdlib.h>
00034 #include <stdio.h>
00035 #include <string.h>
00036
00073
00074 struct list
00075 {
00076 void **elements;
00077 int size;
00078 int back;
00079
00080 int current;
00081
00082 int current_p1, current_p2;
00083 };
00084
00088
00089
00090
00091
00092 static void *(*list_malloc)(size_t) = malloc;
00093 static void *(*list_calloc)(size_t, size_t) = calloc;
00094 static void *(*list_realloc)(void *, size_t) = realloc;
00095 static void (*list_free)(const void *) = (void (*)(const void *))free;
00096
00100 #include <assert.h>
00101 #define assure(EXPR) assert(EXPR)
00102
00107 list *
00108 list_new(void)
00109 {
00110 list *l = list_malloc(sizeof(*l));
00111
00112 l->elements = NULL;
00113 l->size = 0;
00114 l->back = 0;
00115
00116 return l;
00117 }
00118
00125 list *
00126 list_duplicate(const list *l, void * (*duplicate)(const void *))
00127 {
00128 assure( l != NULL );
00129
00130 {
00131 list *dupl = list_malloc(sizeof(*dupl));
00132
00133 dupl->elements = list_malloc((l->size+l->back) * sizeof(*dupl->elements));
00134 dupl->size = l->size;
00135 dupl->back = l->back;
00136 dupl->current = l->current;
00137 dupl->current_p1 = l->current_p1;
00138 dupl->current_p2 = l->current_p2;
00139
00140 {
00141 int i;
00142 for (i = 0; i < l->size; i++) {
00143 if (duplicate != NULL) {
00144 dupl->elements[i] = duplicate(l->elements[i]);
00145 }
00146 else {
00147 dupl->elements[i] = l->elements[i];
00148 }
00149 }
00150 }
00151
00152 return dupl;
00153 }
00154 }
00155
00156
00157
00158
00159
00160
00161
00162 void
00163 list_delete_const(const list **l, void (*delete)(void **))
00164 {
00165 if (l != NULL && *l != NULL) {
00166
00167 if (delete != NULL) {
00168
00169 int i;
00170 for (i = 0; i < (*l)->size; i++) {
00171 delete(&((*l)->elements[i]));
00172 }
00173 }
00174 list_free((*l)->elements);
00175 list_free((*l)); *l = NULL;
00176 }
00177 return;
00178 }
00179
00180 void
00181 list_delete(list **l, void (*delete)(void **))
00182 {
00183 list_delete_const((const list **)l, delete);
00184 return;
00185 }
00186
00187
00188
00189
00190
00191
00192
00193
00194 int
00195 list_size(const list *l)
00196 {
00197 assure( l != NULL );
00198
00199 return l->size;
00200 }
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210 void
00211 list_insert(list *l, void *e)
00212 {
00213 assure( e != NULL );
00214
00215 if (l->back == 0) {
00216 l->back = l->size + 1;
00217 l->elements = list_realloc(l->elements, (l->size + l->back) * sizeof(*l->elements));
00218 }
00219
00220 l->size++;
00221 l->back--;
00222 l->elements[l->size - 1] = e;
00223
00224 return;
00225 }
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245 const void *
00246 list_remove_const(list *l, const void *e)
00247 {
00248 assure( l != NULL );
00249 assure( e != NULL );
00250
00251 {
00252 int i;
00253 int indx = -1;
00254 for (i = l->size - 1; i >= 0 && indx < 0; i--) {
00255 if (l->elements[i] == e) {
00256 indx = i;
00257 }
00258 }
00259
00260 assure( indx >= 0 );
00261
00262 for (i = indx; i < l->size-1; i++) {
00263 l->elements[i] = l->elements[i+1];
00264 }
00265 }
00266
00267 l->size--;
00268 l->back++;
00269
00270 if (l->back > 4 * l->size) {
00271
00272 l->back = l->size;
00273 l->elements = list_realloc(l->elements,
00274 (l->size + l->back) * sizeof(*l->elements));
00275 }
00276
00277 return e;
00278 }
00279
00280 void *
00281 list_remove(list *l, void *e)
00282 {
00283 return (void *)list_remove_const(l, e);
00284 }
00285
00286
00287
00288
00289
00290
00291
00292
00293 void
00294 list_reverse(list *l)
00295 {
00296 int i, k;
00297
00298 assure( l != NULL );
00299
00300 for (i = 0, k = l->size-1; i < k; i++, k--)
00301 {
00302 void *tmp;
00303 tmp = l->elements[i];
00304 l->elements[i] = l->elements[k];
00305 l->elements[k] = tmp;
00306 }
00307
00308 return;
00309 }
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329 const void *
00330 list_first_const(const list *l)
00331 {
00332 assure( l != NULL );
00333
00334 if (l->size == 0) return NULL;
00335
00336
00337
00338
00339 ((list *)l)->current = l->size - 1;
00340 return l->elements[l->current];
00341 }
00342
00343 void *
00344 list_first(list *l)
00345 {
00346 return (void *)list_first_const(l);
00347 }
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358 const void *
00359 list_next_const(const list *l)
00360 {
00361 assure( l != NULL );
00362
00363 if (l->size == 0) return NULL;
00364
00365 ((list *)l)->current -= 1;
00366
00367 if (l->current < 0) return NULL;
00368 else return l->elements[l->current];
00369 }
00370
00371 void *
00372 list_next(list *l)
00373 {
00374 return (void *)list_next_const(l);
00375 }
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405 void
00406 list_first_pair_const(const list *l,
00407 const void **e1,
00408 const void **e2)
00409 {
00410 assure( l != NULL );
00411 assure( e1 != NULL );
00412 assure( e2 != NULL );
00413
00414 if (l->size <= 1) {
00415 *e1 = NULL;
00416 *e2 = NULL;
00417 return;
00418 }
00419
00420 ((list *)l)->current_p1 = l->size - 1;
00421 ((list *)l)->current_p2 = l->size - 2;
00422
00423 *e1 = l->elements[l->current_p1];
00424 *e2 = l->elements[l->current_p2];
00425
00426 return;
00427 }
00428
00429 void
00430 list_first_pair(list *l,
00431 void **e1,
00432 void **e2)
00433 {
00434 list_first_pair_const(l,
00435 (const void **)e1,
00436 (const void **)e2);
00437
00438 return;
00439 }
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451 void
00452 list_next_pair_const(const list *l,
00453 const void **e1,
00454 const void **e2)
00455 {
00456 assure( l != NULL );
00457 assure( e1 != NULL );
00458 assure( e2 != NULL );
00459
00460 if (l->size <= 1) {
00461 *e1 = NULL;
00462 *e2 = NULL;
00463 return;
00464 }
00465
00466 ((list *)l)->current_p2 -= 1;
00467
00468 if (l->current_p2 < 0) {
00469 ((list *)l)->current_p1 -= 1;
00470 ((list *)l)->current_p2 = l->current_p1 - 1;
00471 if (l->current_p2 < 0) {
00472 *e1 = NULL;
00473 *e2 = NULL;
00474 return;
00475 }
00476 *e1 = l->elements[l->current_p1];
00477 *e2 = l->elements[l->current_p2];
00478 return;
00479 }
00480
00481 *e2 = l->elements[l->current_p2];
00482 return;
00483 }
00484
00485 void
00486 list_next_pair(list *l,
00487 void **e1,
00488 void **e2)
00489 {
00490 list_next_pair_const(l, (const void **)e1, (const void **)e2);
00491 return;
00492 }
00493
00506 list *
00507 list_extract(const list *l,
00508 void *(*duplicate)(const void *),
00509 bool (*predicate)(const void *, void *),
00510 void *data)
00511 {
00512 assure( l != NULL );
00513 assure( duplicate != NULL);
00514 assure( predicate != NULL);
00515
00516 {
00517 list *ex = list_new();
00518 int i;
00519
00520 for (i = 0; i < l->size; i++) {
00521 if (predicate(l->elements[i], data)) {
00522 list_insert(ex, duplicate(l->elements[i]));
00523 }
00524 }
00525
00526 return ex;
00527 }
00528 }
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543 void *
00544 list_min(list *l, list_func_lt less_than, void *data)
00545 {
00546 assure( l != NULL );
00547 assure( less_than != NULL);
00548 assure( list_size(l) > 0);
00549
00550 {
00551 int minindex = 0;
00552 int i;
00553 for (i = 1; i < l->size; i++) {
00554 if (less_than(l->elements[i], l->elements[minindex], data))
00555 minindex = i;
00556 }
00557
00558 return l->elements[minindex];
00559 }
00560 }
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571 void *
00572 list_min_val(list *l, list_func_eval eval, void *data)
00573 {
00574 assure( l != NULL );
00575 assure( eval != NULL);
00576 assure( list_size(l) > 0);
00577
00578 {
00579 int minindex = 0;
00580 double minval = eval(l->elements[0], data);
00581 int i;
00582
00583 for (i = 1; i < l->size; i++) {
00584 double val = eval(l->elements[i], data);
00585 if (val < minval) {
00586 minval = val;
00587 minindex = i;
00588 }
00589 }
00590
00591 return l->elements[minindex];
00592 }
00593 }
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604 void *
00605 list_max_val(list *l, list_func_eval eval, void *data)
00606 {
00607 assure( l != NULL );
00608 assure( eval != NULL);
00609 assure( list_size(l) > 0);
00610
00611 {
00612 int maxindex = 0;
00613 double maxval = eval(l->elements[0], data);
00614 int i;
00615
00616 for (i = 1; i < l->size; i++) {
00617 double val = eval(l->elements[i], data);
00618 if (val > maxval) {
00619 maxval = val;
00620 maxindex = i;
00621 }
00622 }
00623
00624 return l->elements[maxindex];
00625 }
00626 }
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637 const void *
00638 list_max_const(const list *l, list_func_lt less_than, void *data)
00639 {
00640 assure( l != NULL );
00641 assure( less_than != NULL);
00642 assure( list_size(l) > 0);
00643
00644 {
00645 int maxindex = 0;
00646 int i;
00647 for (i = 1; i < l->size; i++) {
00648 if (!less_than(l->elements[i], l->elements[maxindex], data))
00649 maxindex = i;
00650 }
00651
00652 return l->elements[maxindex];
00653 }
00654 }
00655
00656 void *
00657 list_max(list *l, list_func_lt less_than, void *data)
00658 {
00659 return (void *)list_max_const(l, less_than, data);
00660 }
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677 static const void *
00678 kth(const void *a[], int k, int n, list_func_lt less_than, void *data)
00679 {
00680 int i, j, lo, hi;
00681
00682 k -= 1;
00683
00684 lo = 0;
00685 hi = n - 1;
00686 while (lo < hi) {
00687 const void *pivot = a[k];
00688 i = lo;
00689 j = hi;
00690 do {
00691 while (less_than(a[i], pivot, data)) i++;
00692 while (less_than(pivot, a[j], data)) {
00693 j--;
00694 }
00695 if (i <= j) {
00696 const void *tmp = a[i];
00697 a[i] = a[j];
00698 a[j] = tmp;
00699 i++; j--;
00700 }
00701 } while (i <= j);
00702 if (j < k) lo = i;
00703 if (k < i) hi = j;
00704 }
00705 return a[k];
00706 }
00707
00708 const void *
00709 list_kth_const(const list *l, int k,
00710 list_func_lt less_than, void *data)
00711 {
00712 void *kp;
00713 void **elemcpy;
00714 int len;
00715
00716 assure( l != NULL );
00717 assure( 1 <= k && k <= l->size );
00718
00719
00720 len = l->size * sizeof(*l->elements);
00721 elemcpy = list_malloc(len);
00722 memcpy(elemcpy, l->elements, len);
00723
00724 kp = (void*)kth((const void **)elemcpy, k, l->size, less_than, data);
00725
00726 list_free(elemcpy);
00727
00728 return kp;
00729 }
00730
00731 void *
00732 list_kth(list *l, int k,
00733 list_func_lt less_than,
00734 void *data)
00735 {
00736 return (void *)list_kth_const(l, k, less_than, data);
00737 }
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747 static
00748 bool val_less_than(const void *e1, const void *e2, void *data)
00749 {
00750 struct {
00751 list_func_eval f;
00752 void *aux_data;
00753 } *d = data;
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766 if (e1 == e2) return false;
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784 return (d->f(e1, d->aux_data) < d->f(e2, d->aux_data));
00785 }
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795 const void *
00796 list_kth_val_const(const list *l, int k, list_func_eval eval, void *data)
00797 {
00798 assure( l != NULL );
00799 assure( 1 <= k && k <= l->size );
00800 assure( eval != NULL );
00801
00802 struct {
00803 list_func_eval f;
00804 void *aux_data;
00805 } d;
00806 d.f = eval;
00807 d.aux_data = data;
00808
00809 return list_kth_const(l, k, val_less_than, &d);
00810 }
00811 void *
00812 list_kth_val(list *l, int k, list_func_eval eval, void *data)
00813 {
00814 return (void *) list_kth_val_const(l, k, eval, data);
00815 }
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829 double
00830 list_median(const list *l, list_func_eval eval, void *data)
00831 {
00832 assure( l != NULL );
00833 assure( eval != NULL );
00834 assure( l->size > 0 );
00835
00836 const void *median_element = list_kth_val_const(l, (l->size+1)/2, eval, data);
00837
00838 double median_val = eval(median_element, data);
00839
00840 if (list_size(l) && 2 == 0)
00841 {
00842 const void *other_median_element =
00843 list_kth_val_const(l, (l->size+2)/2, eval, data);
00844
00845 median_val = (median_val + eval(other_median_element, data) ) / 2.0;
00846 }
00847
00848 return median_val;
00849 }
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860 double
00861 list_mean(const list *l, list_func_eval eval, void *data)
00862 {
00863 assure( l != NULL );
00864 assure( eval != NULL );
00865 assure( l->size > 0 );
00866
00867 double result = eval(l->elements[0], data);
00868 int i;
00869
00870 for (i = 1; i < l->size; i++) {
00871 result += eval(l->elements[i], data);
00872 }
00873
00874 result /= l->size;
00875
00876 return result;
00877 }
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898 double
00899 list_mean_optimal(const list *l,
00900 list_func_eval eval, void *data_eval,
00901 list_func_eval eval_err, void *data_err,
00902 double *err,
00903 double *red_chisq)
00904 {
00905 assure( l != NULL );
00906 assure( l->size >= 1 );
00907 assure( red_chisq == NULL || l->size >= 2 );
00908 assure( eval != NULL );
00909 assure( eval_err != NULL );
00910 assure( err != NULL );
00911
00912 double sum_weights = 0;
00913 double opt_average = 0;
00914 int i;
00915
00916 for (i = 0; i < l->size; i++) {
00917 void *e = l->elements[i];
00918 double sigma = eval_err(e, data_err);
00919
00920 assure( sigma > 0 );
00921
00922 double weight = 1/(sigma*sigma);
00923
00924 opt_average += eval(e, data_eval) * weight;
00925 sum_weights += weight;
00926 }
00927 opt_average /= sum_weights;
00928 *err = 1 / sqrt(sum_weights);
00929
00930 if (red_chisq != NULL) {
00931 *red_chisq = 0;
00932 for (i = 0; i < l->size; i++) {
00933 void *e = l->elements[i];
00934 double residual = ((eval(e, data_eval) - opt_average)) / eval_err(e, data_err);
00935 *red_chisq += residual * residual;
00936 }
00937 *red_chisq /= (l->size - 1);
00938 }
00939
00940 return opt_average;
00941 }
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952 static double
00953 abs_dev(const void *e1, void *data)
00954 {
00955 struct {
00956 double ref;
00957 list_func_eval f;
00958 void *aux_data;
00959 } *d = data;
00960
00961
00962 return fabs(d->f(e1, d->aux_data) - d->ref);
00963 }
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974 double
00975 list_mad(list *l, list_func_eval eval, void *data)
00976 {
00977 assure( l != NULL );
00978 assure( eval != NULL );
00979
00980 double median = list_median(l, eval, data);
00981
00982 struct {
00983 double ref;
00984 list_func_eval f;
00985 void *aux_data;
00986 } d;
00987
00988 d.ref = median;
00989 d.f = eval;
00990 d.aux_data = data;
00991
00992 return list_median(l, abs_dev, &d);
00993 }
00994