isl_val_gmp.c

Go to the documentation of this file.

#include <string.h>
#include <isl/val_gmp.h>
#include <isl_val_private.h>
 
/* Return a reference to an isl_val representing the integer "z".
 */
__isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx, mpz_t z)
{
  isl_val *v;
 
  v = isl_val_alloc(ctx);
  if (!v)
    return NULL;
 
  isl_int_set(v->n, z);
  isl_int_set_si(v->d, 1);
 
  return v;
}
 
/* Return a reference to an isl_val representing the rational value "n"/"d".
 */
__isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx, const mpz_t n, const mpz_t d)
{
  isl_val *v;
 
  v = isl_val_alloc(ctx);
  if (!v)
    return NULL;
 
  isl_int_set(v->n, n);
  isl_int_set(v->d, d);
 
  return isl_val_normalize(v);
}
 
/* Extract the numerator of a rational value "v" in "z".
 *
 * If "v" is not a rational value, then the result is undefined.
 */
int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z)
{
  if (!v)
    return -1;
  if (!isl_val_is_rat(v))
    isl_die(isl_val_get_ctx(v), isl_error_invalid,
      "expecting rational value", return -1);
  mpz_set(z, v->n);
  return 0;
}
 
/* Extract the denominator of a rational value "v" in "z".
 *
 * If "v" is not a rational value, then the result is undefined.
 */
int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z)
{
  if (!v)
    return -1;
  if (!isl_val_is_rat(v))
    isl_die(isl_val_get_ctx(v), isl_error_invalid,
      "expecting rational value", return -1);
  mpz_set(z, v->d);
  return 0;
}
 
/* Return a reference to an isl_val representing the unsigned
 * integer value stored in the "n" chunks of size "size" at "chunks".
 * The least significant chunk is assumed to be stored first.
 */
__isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx, size_t n,
  size_t size, const void *chunks)
{
  isl_val *v;
 
  v = isl_val_alloc(ctx);
  if (!v)
    return NULL;
 
  mpz_import(v->n, n, -1, size, 0, 0, chunks);
  isl_int_set_si(v->d, 1);
 
  return v;
}
 
/* Return the number of chunks of size "size" required to
 * store the absolute value of the numerator of "v".
 */
isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v, size_t size)
{
  if (!v)
    return isl_size_error;
 
  if (!isl_val_is_rat(v))
    isl_die(isl_val_get_ctx(v), isl_error_invalid,
      "expecting rational value", return isl_size_error);
 
  size *= 8;
  return (mpz_sizeinbase(v->n, 2) + size - 1) / size;
}
 
/* Store a representation of the absolute value of the numerator of "v"
 * in terms of chunks of size "size" at "chunks".
 * The least significant chunk is stored first.
 * The number of chunks in the result can be obtained by calling
 * isl_val_n_abs_num_chunks.  The user is responsible for allocating
 * enough memory to store the results.
 *
 * In the special case of a zero value, isl_val_n_abs_num_chunks will
 * return one, while mpz_export will not fill in any chunks.  We therefore
 * do it ourselves.
 */
isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v, size_t size,
  void *chunks)
{
  if (!v || !chunks)
    return isl_stat_error;
 
  if (!isl_val_is_rat(v))
    isl_die(isl_val_get_ctx(v), isl_error_invalid,
      "expecting rational value", return isl_stat_error);
 
  mpz_export(chunks, NULL, -1, size, 0, 0, v->n);
  if (isl_val_is_zero(v))
    memset(chunks, 0, size);
 
  return isl_stat_ok;
}