nsz Git - libfirm/blob - vector.c

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