isl_vec.c

   1 /*
   2  * Copyright 2008-2009 Katholieke Universiteit Leuven
   3  *
   4  * Use of this software is governed by the GNU LGPLv2.1 license
   5  *
   6  * Written by Sven Verdoolaege, K.U.Leuven, Departement
   7  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
   8  */
   9
  10 #include <isl_ctx_private.h>
  11 #include <isl/seq.h>
  12 #include <isl/vec.h>
  13
  14 struct isl_vec *isl_vec_alloc(struct isl_ctx *ctx, unsigned size)
  15 {
  16         struct isl_vec *vec;
  17
  18         vec = isl_alloc_type(ctx, struct isl_vec);
  19         if (!vec)
  20                 return NULL;
  21
  22         vec->block = isl_blk_alloc(ctx, size);
  23         if (isl_blk_is_error(vec->block))
  24                 goto error;
  25
  26         vec->ctx = ctx;
  27         isl_ctx_ref(ctx);
  28         vec->ref = 1;
  29         vec->size = size;
  30         vec->el = vec->block.data;
  31
  32         return vec;
  33 error:
  34         isl_blk_free(ctx, vec->block);
  35         return NULL;
  36 }
  37
  38 __isl_give isl_vec *isl_vec_extend(__isl_take isl_vec *vec, unsigned size)
  39 {
  40         if (!vec)
  41                 return NULL;
  42         if (size <= vec->size)
  43                 return vec;
  44
  45         vec = isl_vec_cow(vec);
  46         if (!vec)
  47                 return NULL;
  48
  49         vec->block = isl_blk_extend(vec->ctx, vec->block, size);
  50         if (!vec->block.data)
  51                 goto error;
  52
  53         vec->size = size;
  54         vec->el = vec->block.data;
  55
  56         return vec;
  57 error:
  58         isl_vec_free(vec);
  59         return NULL;
  60 }
  61
  62 __isl_give isl_vec *isl_vec_zero_extend(__isl_take isl_vec *vec, unsigned size)
  63 {
  64         int extra;
  65
  66         if (!vec)
  67                 return NULL;
  68         if (size <= vec->size)
  69                 return vec;
  70
  71         vec = isl_vec_cow(vec);
  72         if (!vec)
  73                 return NULL;
  74
  75         extra = size - vec->size;
  76         vec = isl_vec_extend(vec, size);
  77         if (!vec)
  78                 return NULL;
  79
  80         isl_seq_clr(vec->el + size - extra, extra);
  81
  82         return vec;
  83 }
  84
  85 struct isl_vec *isl_vec_copy(struct isl_vec *vec)
  86 {
  87         if (!vec)
  88                 return NULL;
  89
  90         vec->ref++;
  91         return vec;
  92 }
  93
  94 struct isl_vec *isl_vec_dup(struct isl_vec *vec)
  95 {
  96         struct isl_vec *vec2;
  97
  98         if (!vec)
  99                 return NULL;
 100         vec2 = isl_vec_alloc(vec->ctx, vec->size);
 101         isl_seq_cpy(vec2->el, vec->el, vec->size);
 102         return vec2;
 103 }
 104
 105 struct isl_vec *isl_vec_cow(struct isl_vec *vec)
 106 {
 107         struct isl_vec *vec2;
 108         if (!vec)
 109                 return NULL;
 110
 111         if (vec->ref == 1)
 112                 return vec;
 113
 114         vec2 = isl_vec_dup(vec);
 115         isl_vec_free(vec);
 116         return vec2;
 117 }
 118
 119 void isl_vec_free(struct isl_vec *vec)
 120 {
 121         if (!vec)
 122                 return;
 123
 124         if (--vec->ref > 0)
 125                 return;
 126
 127         isl_ctx_deref(vec->ctx);
 128         isl_blk_free(vec->ctx, vec->block);
 129         free(vec);
 130 }
 131
 132 __isl_give isl_printer *isl_printer_print_vec(__isl_take isl_printer *printer,
 133         __isl_keep isl_vec *vec)
 134 {
 135         int i;
 136
 137         if (!printer || !vec)
 138                 goto error;
 139
 140         printer = isl_printer_print_str(printer, "[");
 141         for (i = 0; i < vec->size; ++i) {
 142                 if (i)
 143                         printer = isl_printer_print_str(printer, ",");
 144                 printer = isl_printer_print_isl_int(printer, vec->el[i]);
 145         }
 146         printer = isl_printer_print_str(printer, "]");
 147
 148         return printer;
 149 error:
 150         isl_printer_free(printer);
 151         return NULL;
 152 }
 153
 154 void isl_vec_dump(struct isl_vec *vec)
 155 {
 156         isl_printer *printer;
 157
 158         if (!vec)
 159                 return;
 160
 161         printer = isl_printer_to_file(vec->ctx, stderr);
 162         printer = isl_printer_print_vec(printer, vec);
 163         printer = isl_printer_end_line(printer);
 164
 165         isl_printer_free(printer);
 166 }
 167
 168 __isl_give isl_vec *isl_vec_clr(__isl_take isl_vec *vec)
 169 {
 170         vec = isl_vec_cow(vec);
 171         if (!vec)
 172                 return NULL;
 173         isl_seq_clr(vec->el, vec->size);
 174         return vec;
 175 }
 176
 177 void isl_vec_lcm(struct isl_vec *vec, isl_int *lcm)
 178 {
 179         isl_seq_lcm(vec->block.data, vec->size, lcm);
 180 }
 181
 182 /* Given a rational vector, with the denominator in the first element
 183  * of the vector, round up all coordinates.
 184  */
 185 struct isl_vec *isl_vec_ceil(struct isl_vec *vec)
 186 {
 187         vec = isl_vec_cow(vec);
 188         if (!vec)
 189                 return NULL;
 190
 191         isl_seq_cdiv_q(vec->el + 1, vec->el + 1, vec->el[0], vec->size - 1);
 192
 193         isl_int_set_si(vec->el[0], 1);
 194
 195         return vec;
 196 }
 197
 198 struct isl_vec *isl_vec_normalize(struct isl_vec *vec)
 199 {
 200         if (!vec)
 201                 return NULL;
 202         isl_seq_normalize(vec->ctx, vec->el, vec->size);
 203         return vec;
 204 }
 205
 206 __isl_give isl_vec *isl_vec_scale(__isl_take isl_vec *vec, isl_int m)
 207 {
 208         if (isl_int_is_one(m))
 209                 return vec;
 210         vec = isl_vec_cow(vec);
 211         if (!vec)
 212                 return NULL;
 213         isl_seq_scale(vec->el, vec->el, m, vec->size);
 214         return vec;
 215 }
 216
 217 __isl_give isl_vec *isl_vec_add(__isl_take isl_vec *vec1,
 218         __isl_take isl_vec *vec2)
 219 {
 220         vec1 = isl_vec_cow(vec1);
 221         if (!vec1 || !vec2)
 222                 goto error;
 223
 224         isl_assert(vec1->ctx, vec1->size == vec2->size, goto error);
 225
 226         isl_seq_combine(vec1->el, vec1->ctx->one, vec1->el,
 227                         vec1->ctx->one, vec2->el, vec1->size);
 228
 229         isl_vec_free(vec2);
 230         return vec1;
 231 error:
 232         isl_vec_free(vec1);
 233         isl_vec_free(vec2);
 234         return NULL;
 235 }