nsz Git - libfirm/blob - vector.c

   1 #include <string.h>
   2
   3 #include "adt/array.h"
   4
   5 #include "vector.h"
   6
   7 num pbqp_add(num x, num y)
   8 {
   9         if (x == INF_COSTS || y == INF_COSTS) return INF_COSTS;
  10
  11         num res = x + y;
  12
  13         /* No positive overflow. */
  14         assert(x < 0 || y < 0 || res >= x);
  15         assert(x < 0 || y < 0 || res >= y);
  16
  17         /* No negative overflow. */
  18         assert(x > 0 || y > 0 || res <= x);
  19         assert(x > 0 || y > 0 || res <= y);
  20
  21         /* Result is not infinity.*/
  22         assert(res < INF_COSTS);
  23
  24         return res;
  25 }
  26
  27 vector *vector_alloc(pbqp *pbqp, unsigned length)
  28 {
  29         assert(length > 0);
  30         vector *vec = obstack_alloc(&pbqp->obstack, sizeof(*vec) + sizeof(*vec->entries) * length);
  31         assert(vec);
  32
  33         vec->len = length;
  34         memset(vec->entries, 0, sizeof(*vec->entries) * length);
  35
  36         return vec;
  37 }
  38
  39 vector *vector_copy(pbqp *pbqp, vector *v)
  40 {
  41         unsigned  len  = v->len;
  42         vector   *copy = obstack_copy(&pbqp->obstack, v, sizeof(*copy) + sizeof(*copy->entries) * len);
  43         assert(copy);
  44
  45         return copy;
  46 }
  47
  48 void vector_add(vector *sum, vector *summand)
  49 {
  50         int i;
  51         int len;
  52
  53         assert(sum);
  54         assert(summand);
  55         assert(sum->len == summand->len);
  56
  57         len = sum->len;
  58
  59         for (i = 0; i < len; ++i) {
  60                 sum->entries[i].data = pbqp_add(sum->entries[i].data,
  61                                 summand->entries[i].data);
  62         }
  63 }
  64
  65 void vector_set(vector *vec, unsigned index, num value)
  66 {
  67         assert(index < vec->len);
  68         vec->entries[index].data = value;
  69 }
  70
  71 #if KAPS_ENABLE_VECTOR_NAMES
  72 void vector_set_description(vector *vec, unsigned index, char *name)
  73 {
  74         assert(index < vec->len);
  75         vec->entries[index].name = name;
  76 }
  77 #endif
  78
  79 void vector_add_value(vector *vec, num value)
  80 {
  81         unsigned index;
  82         unsigned len;
  83
  84         assert(vec);
  85
  86         len = vec->len;
  87
  88         for (index = 0; index < len; ++index) {
  89                 vec->entries[index].data = pbqp_add(vec->entries[index].data, value);
  90         }
  91 }
  92
  93 void vector_add_matrix_col(vector *vec, pbqp_matrix *mat, unsigned col_index)
  94 {
  95         unsigned index;
  96         unsigned len;
  97
  98         assert(vec);
  99         assert(mat);
 100         assert(vec->len == mat->rows);
 101         assert(col_index < mat->cols);
 102
 103         len = vec->len;
 104
 105         for (index = 0; index < len; ++index) {
 106                 vec->entries[index].data = pbqp_add(vec->entries[index].data, mat->entries[index * mat->cols + col_index]);
 107         }
 108 }
 109
 110 void vector_add_matrix_row(vector *vec, pbqp_matrix *mat, unsigned row_index)
 111 {
 112         unsigned index;
 113         unsigned len;
 114
 115         assert(vec);
 116         assert(mat);
 117         assert(vec->len == mat->cols);
 118         assert(row_index < mat->rows);
 119
 120         len = vec->len;
 121
 122         for (index = 0; index < len; ++index) {
 123                 vec->entries[index].data = pbqp_add(vec->entries[index].data,
 124                                 mat->entries[row_index * mat->cols + index]);
 125         }
 126 }
 127
 128 num vector_get_min(vector *vec)
 129 {
 130         unsigned index;
 131         unsigned len;
 132         num      min = INF_COSTS;
 133
 134         assert(vec);
 135
 136         len = vec->len;
 137         assert(len > 0);
 138
 139         for (index = 0; index < len; ++index) {
 140                 num elem = vec->entries[index].data;
 141
 142                 if (elem < min) {
 143                         min = elem;
 144                 }
 145         }
 146
 147         return min;
 148 }
 149
 150 unsigned vector_get_min_index(vector *vec)
 151 {
 152         unsigned index;
 153         unsigned len;
 154         unsigned min_index = 0;
 155         num      min       = INF_COSTS;
 156
 157         assert(vec);
 158
 159         len = vec->len;
 160         assert(len > 0);
 161
 162         for (index = 0; index < len; ++index) {
 163                 num elem = vec->entries[index].data;
 164
 165                 if (elem < min) {
 166                         min = elem;
 167                         min_index = index;
 168                 }
 169         }
 170
 171         return min_index;
 172 }