Laboratoire de l'Informatique et du Parallélisme » Pobyso

/** @file pobyso.c

 * Integration of Sollya to C programs

 *

 * @author S.T.

 * @date 2011-10-12

 *

 * @todo write pobyso_is_monomial function <br>

 *       write pobyso_is_free_var_int_poson_power function

 */

/******************************************************************************/

/* Headers, applying the "particular to general" convention.*/

#include "pobyso.h"

/* includes of local headers */

/* includes of project headers */

/* includes of system headers */

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

/* Other declarations */

/* Internal prototypes */

void

pobyso_error_message(char *functionName, char *messageName, char* message);

/* Types, constants and macros definitions */

/* Global variables */

/* Functions */

/* @see pobyso.h#pobyso_autoprint */

void

pobyso_autoprint(sollya_obj_t objSo)

{

  sollya_lib_autoprint(objSo, NULL);

} /* End pobyso_autoprint. */

/* @see pobyso.h#pobyso_dirty_find_zeros */

mpfr_t*

pobyso_dirty_find_zeros_bounds(pobyso_func_exp_t funcExpSo,

                              mpfr_t lowerBound,

                              mpfr_t upperBound,

                              int* zerosCount)

{

  pobyso_range_t rangeSo;

  sollya_obj_t zerosListSo    = NULL;

  sollya_obj_t* zerosArraySo  = NULL;

  mpfr_t* zerosArrayMp        = NULL;

  pobyso_precision_t prec;

  int endEll = 0;

  int i,j;

  /* Arguments check. */

  *zerosCount = -1;

  if (funcExpSo == NULL )

  {

    pobyso_error_message("pobyso_dirty_find_zeros",

                        "NULL_POINTER_ARGUMENT",

                        "The funcExpSo argument is a NULL pointer");

    return NULL;

  }

  if (mpfr_cmp(lowerBound, upperBound) > 0)

  {

    pobyso_error_message("pobyso_dirty_find_zeros",

                        "INVALID_INTERVAL_ARGUMENT",

                        "The lower bound is larger than the upper bound");

    return NULL;

  }

  /* Make a range out of the bounds. */

  rangeSo = sollya_lib_range_from_bounds(lowerBound, upperBound);

  if (rangeSo == NULL)

  {

    return NULL;

  }

  zerosListSo = sollya_lib_dirtyfindzeros(funcExpSo, rangeSo);

  if (zerosListSo == NULL)

  {

    return NULL;

  }

  sollya_lib_clear_obj(rangeSo);

  /* Transform the Sollya list into an MPFR list. */

  if (! sollya_lib_get_list_elements(&zerosArraySo,

                                      zerosCount,

                                      &endEll,

                                      zerosListSo))

  {

    sollya_lib_clear_obj(zerosListSo);

    *zerosCount = -1;

    return NULL;

  }

  sollya_lib_clear_obj(zerosListSo);

  zerosArrayMp = (mpfr_t*) malloc(*zerosCount * sizeof(mpfr_t));

  if (zerosArrayMp == NULL)

  {

    pobyso_error_message("pobyso_dirty_find_zeros",

                          "MEMORY_ALLOCATION_ERROR",

                          "Could not allocate zeroes array");

    *zerosCount = -1;

    return NULL;

  }

  for (i = 0 ; i < *zerosCount ; i++)

  {

    if (! sollya_lib_get_prec_of_constant(&prec, zerosArraySo[i]))

    {

      /* Clean up the already allocated MPFRs. */

      for (j = 0 ; j < i ; j++) mpfr_clear(zerosArrayMp[j]);

      /* Clean up the zerosArrayMp array itself. */

      free(zerosArrayMp);

      /* Clean up what is left in the zerosArraySo. */

      for (j = i ; j < *zerosCount ; j++) sollya_lib_clear_obj(zerosArraySo[j]);

      /* Clean up the zerosArraySo array itself. */

      sollya_lib_free(zerosArraySo);

      *zerosCount = -1;

      return NULL;

    }

    mpfr_init2(zerosArrayMp[i], prec);

    if (! sollya_lib_get_constant(zerosArrayMp[i], zerosArraySo[i]))

    {

      /* Clean up the already allocated MPFRs. */

      for (j = 0 ; j <= i ; j++) mpfr_clear(zerosArrayMp[j]);

      /* Clean up the zerosArrayMp array itself. */

      free(zerosArrayMp);

      /* Clean up what is left in the zerosArraySo. */

      for (j = i ; j < *zerosCount ; j++) sollya_lib_clear_obj(zerosArraySo[j]);

      /* Clean up the zerosArraySo array itself. */

      sollya_lib_free(zerosArraySo);

      *zerosCount = -1;

      return NULL;

    }

    sollya_lib_clear_obj(zerosArraySo[i]);

  } /* End for i. */

  sollya_lib_free(zerosArraySo);

  return zerosArrayMp;

} /* End pobyso_dirty_find_zeros. */

/* @see pobyso.h#pobyso_evaluate_constant */

int

pobyso_evaluate_constant(pobyso_func_exp_t functionSo,

                          mpfr_t argumentMp,

                          mpfr_t evaluationMp)

{

  sollya_obj_t argumentSo   = NULL;

  sollya_obj_t evaluationSo = NULL;

  mpfr_t evaluationTmpMp1;

  mpfr_t evaluationTmpMp2;

  mpfr_prec_t evalPrec      = 0;

  /* Test argument. */

  if (functionSo == NULL || argumentMp == NULL || evaluationMp == NULL)

  {

    pobyso_error_message("pobyso_evaluate_constant",

                        "NULL_POINTER_ARGUMENT",

                        "One of the arguments is a NULL pointer");

    return 1;

  }

  if (! sollya_lib_obj_is_function(functionSo))

  {

    pobyso_error_message("pobyso_evaluate_constant",

                        "INVALID_TYPE_ARGUMENT",

                     "The functionSo argument is not a functional expression");

    return 1;

  }

  /* Function evaluation and checks. */

  argumentSo    = sollya_lib_constant(argumentMp);

  evaluationSo  = sollya_lib_evaluate(functionSo, argumentSo);

  /* Not needed any more. */

  //pobyso_autoprint(evaluationSo);

  sollya_lib_clear_obj(argumentSo);

  /* The range case: we return the mean of the bounds. The result

   * is not faithfully rounded. */

  if (sollya_lib_obj_is_range(evaluationSo))

  {

    //pobyso_autoprint(evaluationSo);

    if (sollya_lib_get_prec_of_range(&evalPrec, evaluationSo))

    {

      mpfr_init2(evaluationTmpMp1, evalPrec);

      mpfr_init2(evaluationTmpMp2, evalPrec);

      if (sollya_lib_get_bounds_from_range(evaluationTmpMp1,

                                       evaluationTmpMp2,

                                       evaluationSo))

      {

        /* Compute the mean of the bounds. */

        mpfr_clear(evaluationMp);

        mpfr_init2(evaluationMp, evalPrec);

        mpfr_add(evaluationMp,evaluationTmpMp1,evaluationTmpMp2,MPFR_RNDN);

        mpfr_div_2ui(evaluationMp, evaluationMp, 1, MPFR_RNDN);

        mpfr_clear(evaluationTmpMp1);

        mpfr_clear(evaluationTmpMp2);

        sollya_lib_clear_obj(evaluationSo);

        /* It may happen, in this case, when the bounds are -Infty  and

         * +Infty, that the average is NaN. */

        if (mpfr_nan_p(evaluationMp))

        {

          return POBYSO_NAN;

        }

        else

        {

          return POBYSO_UNFAITHFUL;

        }

      }

      else /* Could not get the values of the bounds. */

      {

        sollya_lib_clear_obj(evaluationSo);

        return 1;

      }

    }

    else /* Could not get the precision of the range. */

    {

      sollya_lib_clear_obj(evaluationSo);

      return 1;

    }

  } /* End the evaluation is a range. */

  /* From now on, we assume that the evaluation is constant. */

  if (sollya_lib_get_prec_of_constant(&evalPrec, evaluationSo))

  {

    mpfr_init2(evaluationTmpMp1, evalPrec);

    if (sollya_lib_get_constant(evaluationTmpMp1, evaluationSo))

    {

      /* Deal with the NaN case. */

      if (mpfr_nan_p(evaluationTmpMp1))

      {

        mpfr_clear(evaluationTmpMp1);

        sollya_lib_clear_obj(evaluationSo);

        return POBYSO_NAN;

      }

      else /* The evaluation is not NaN. */

      {

        mpfr_clear(evaluationMp);

        mpfr_init2(evaluationMp, evalPrec);

        mpfr_set(evaluationMp, evaluationTmpMp1, MPFR_RNDN);

        mpfr_clear(evaluationTmpMp1);

        sollya_lib_clear_obj(evaluationSo);

        return 0;

      }

    }

    else /* Could not recover the value of the evaluation. */

    {

      mpfr_clear(evaluationTmpMp1);

      sollya_lib_clear_obj(evaluationSo);

      return 1;

    }

  }

  else /* Could not get the precision of the evaluation. */

  {

    sollya_lib_clear_obj(evaluationSo);

    return 0;

  }

}

/* End pobyso_evaluate_constant. */

/* @see pobyso.h#pobyso_get_verbosity */

int

pobyso_get_verbosity()

{

  sollya_obj_t verbositySo = NULL;

  int verbosity            = 0;

  verbositySo = sollya_lib_get_verbosity();

  sollya_lib_get_constant_as_int(&verbosity,verbositySo);

  sollya_lib_clear_obj(verbositySo);

  return verbosity;

} /* End pobyso_get_verbosity. */

/** @see pobyso.h#pobyso_is_constant_expression

 * Strategy: rely on sollya_lib_get_constant. It return 1, when the

 * expression is constant.

 */

int

pobyso_is_constant_expression(sollya_obj_t obj_to_test)

{

  mpfr_t dummy;

  int test;

  int initial_verbosity_level      = 0;

  /* Test argument. */

  if (obj_to_test == NULL)

  {

    pobyso_error_message("pobyso_is_constant_expression",

                        "NULL_POINTER_ARGUMENT",

                        "The expression is a NULL pointer");

    return 0;

  }

  initial_verbosity_level = pobyso_set_verbosity_off();

  /* In Sollya, constant are functional expressions. */

  if (! sollya_lib_obj_is_function(obj_to_test))

  {

    pobyso_set_verbosity_to(initial_verbosity_level);

    return 0;

  }

  mpfr_init2(dummy,64);

  /* Call to previous Sollya function resets verbosity. */

  /* Todo: change verbosity suppression strategy with a message call back. */

  pobyso_set_verbosity_off();

  /* Try to convert the would be constant into an MPFR number. */

  /* If OK, we indeed have a constant. If the conversion fails, return 0. */

  test = sollya_lib_get_constant(dummy, obj_to_test);

  pobyso_set_verbosity_to(initial_verbosity_level);

  if (test)

  {

    if(mpfr_number_p(dummy) || mpfr_inf_p(dummy))

    {

      mpfr_clear(dummy);

      return test;

    }

    else /* We do not consider NaNs as constants. */

    {

      mpfr_clear(dummy);

      return 0;

    }

  }

  else

  {

    mpfr_clear(dummy);

    return 0;

  }

} /* End pobyso_is_constant_expression. */

/** @see pobyso.h#pobyso_is_monomial. */

int

pobyso_is_int(pobyso_func_exp_t exprSo)

{

  mpfr_t float1M;

  mpfr_t float2M;

  mpfr_t tempFloat1M;

  mpfr_t tempFloat2M;

  mpfr_prec_t prec;

  int64_t asInt;

  sollya_obj_t newConstantSo = NULL;

  /* Arguments check. */

  if (exprSo == NULL)

  {

    pobyso_error_message("pobyso_is_free_var_posze_int_power",

                        "NULL_POINTER_ARGUMENT",

                        "The expression is a NULL pointer");

    return 0;

  }

  //fprintf(stdout, "Not NULL.\n"); pobyso_autoprint(exprSo);

  if (! pobyso_is_constant_expression(exprSo)) return 0;

  if (! sollya_lib_get_constant_as_int64(&asInt, exprSo)) return 0;

  if (asInt == INT64_MIN || asInt == INT64_MAX) return 0;

  /* Some constant integer expression can't have their precision computed

   * (e.g. cos(pi). */

  if (! sollya_lib_get_prec_of_constant(&prec, exprSo))

  {

    mpfr_init2(tempFloat1M, 165);

    mpfr_init2(tempFloat2M, 165);

    mpfr_abs(tempFloat1M, tempFloat1M, MPFR_RNDN);

    mpfr_log2(tempFloat2M, tempFloat1M, MPFR_RNDU);

    mpfr_rint_ceil(tempFloat1M, tempFloat2M, MPFR_RNDU);

    prec = mpfr_get_si(tempFloat1M, MPFR_RNDN) + 10;

    if (prec < 1024) prec = 1024;

    mpfr_clear(tempFloat1M);

    mpfr_clear(tempFloat2M);

    mpfr_init2(float1M, prec);

    if (!sollya_lib_get_constant(float1M, exprSo))

    {

      mpfr_clear(float1M);

      return 0;

    }

  }

  else /* Precision could be given. */

  {

    mpfr_init2(float1M, prec);

    if (! sollya_lib_get_constant(float1M, exprSo))

    {

      mpfr_clear(float1M);

      return 0;

    }

  }

  if (mpfr_nan_p(float1M) || mpfr_inf_p(float1M))

  {

    mpfr_clear(float1M);

    return 0;

  }

  if ((newConstantSo = sollya_lib_constant_from_int64(asInt)) == NULL)

  {

    mpfr_clear(float1M);

    return 0;

  }

  sollya_lib_get_prec_of_constant(&prec, newConstantSo);

  mpfr_init2(float2M, prec);

  sollya_lib_get_constant(float2M, newConstantSo);

  if (mpfr_cmp(float1M, float2M) == 0)

  {

    mpfr_clear(float1M);

    mpfr_clear(float2M);

    sollya_lib_clear_obj(newConstantSo);

    return 1;

  }

  else

  {

    mpfr_clear(float1M);

    mpfr_clear(float2M);

    sollya_lib_clear_obj(newConstantSo);

    return 0;

  }

} /* End pobyso_is_int. */

/** @see pobyso.h#pobyso_is_monomial.

 * Strategy: check that the object is a functional expression and

 * if so check that it is made of cte * free_var ^ some_power where :

 * - cte is a constant expression (a per pobyso_is_constant_experession;

 * - some_power is a positive or null power. t*/

int

pobyso_is_monomial(sollya_obj_t objSo)

{

  int arity;

  sollya_obj_t subFun1So = NULL;

  sollya_obj_t subFun2So = NULL;

  sollya_obj_t subFun3So = NULL;

  sollya_base_function_t head = 0;

  long int exponent = 0;

  long int exprIntValue = 0;

  /* Arguments check. */

  if (objSo == NULL)

  {

    pobyso_error_message("pobyso_is_monomial",

                        "NULL_POINTER_ARGUMENT",

                        "The expression is a NULL pointer");

    return 0;

  }

  /* The object must be a function. */

  if (! sollya_lib_obj_is_function(objSo)) return 0;

  /* Check if it is the 1 constant. */

  if (pobyso_is_int(objSo))

  {

    if (! sollya_lib_get_constant_as_int64(&exprIntValue, objSo))

    {

      return 0;

    }

    else

    {

      if (exprIntValue == 1) return 1;

      else return 0;

    }

  }

  if (! sollya_lib_decompose_function(objSo,

                                      &head,

                                      &arity,

                                      &subFun1So,

                                      &subFun2So,

                                      NULL)) return 0;

  if (arity > 2)

  {

    if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

    if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

    return 0;

  }

  /* Arity == 1 must be free variable by itself. */

  if (arity == 1 && head == SOLLYA_BASE_FUNC_FREE_VARIABLE)

  {

    if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

    if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

    return 1;

  }

  else

  {

    /* Another expression. Must be: free variable  ^ poze integer. */

    if (arity == 2)

    {

      if (head != SOLLYA_BASE_FUNC_POW)

      {

        if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

        if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

        return 0;

      }

      if (! pobyso_is_int(subFun2So))

      {

        if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

        if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

        return 0;

      }

      if (! sollya_lib_get_constant_as_int64(&exponent, subFun2So))

      {

        if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

        if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

        return 0;

      }

      if (exponent < 0)

      {

        if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

        if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

        return 0;

      }

      if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

      /* Check that the first subfunction is the free variable. */

      if (! sollya_lib_decompose_function(subFun1So,

                                          &head,

                                          &arity,

                                          &subFun2So,

                                          &subFun3So,

                                          NULL))

      {

        if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

        return 0;

      }

      if (arity == 1 && head == SOLLYA_BASE_FUNC_FREE_VARIABLE)

      {

        if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

        if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

        if (subFun3So != NULL) sollya_lib_clear_obj(subFun3So);

        return 1;

      }

      else

      {

        if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

        if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

        return 0;

      }

    } /* End if arity == 2. */

  } /* End else if arity == 1. */

  return 0;

} /* End pobyso_is_monomial. */

/** @see pobyso.h#pobyso_is_polynomial_term.

 * Strategy: check that the object is a functional expression and

 * if so check that it is made of cte * monomial.

 */

int

pobyso_is_polynomial_term(sollya_obj_t objSo)

{

  int arity;

  sollya_obj_t subFun1So = NULL;

  sollya_obj_t subFun2So = NULL;

  sollya_base_function_t head = 0;

  /* Arguments check. */

  if (objSo == NULL)

  {

    pobyso_error_message("pobyso_is_polynomial_term",

                        "NULL_POINTER_ARGUMENT",

                        "The expression is a NULL pointer");

    return 0;

  }

  /* The object must be a function. */

  if (! sollya_lib_obj_is_function(objSo)) return 0;

  /* A constant expression is degree 0 polynomial term. */

  if (pobyso_is_constant_expression(objSo)) return 1;

  /* A monomial is a polynomial term. */

  if (pobyso_is_monomial(objSo)) return 1;

  /* Decompose the functional expression and study the elements. */

  if (! sollya_lib_decompose_function(objSo,

                                      &head,

                                      &arity,

                                      &subFun1So,

                                      &subFun2So,

                                      NULL)) return 0;

  /* Monomial case has been dealt with abobe. */

  if (arity != 2)

  {

    if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

    if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

    return 0;

  }

  /* The expression must be: cte  * monomial or monomial * cte. */

  if (head != SOLLYA_BASE_FUNC_MUL)

  {

    if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

    if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

    return 0;

  }

  if (! pobyso_is_monomial(subFun2So))

  {

    if (! pobyso_is_constant_expression(subFun2So) ||

        ! pobyso_is_monomial(subFun1So))

    {

      if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

      if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

      return 0;

    }

  }

  else

  {

    if (! pobyso_is_constant_expression(subFun1So))

    {

      if (subFun1So != NULL) sollya_lib_clear_obj(subFun1So);

      if (subFun2So != NULL) sollya_lib_clear_obj(subFun2So);

      return 0;

    }

  }

  return 1;

} /* End pobyso_is_polynomial_term. */

/** @see pobyso.h#pobyso_new_monomial. */

pobyso_func_exp_t

pobyso_new_monomial(pobyso_func_exp_t coefficientSo, long degree)

{

  sollya_obj_t degreeSo   = NULL;

  sollya_obj_t varToPowSo = NULL;

  sollya_obj_t monomialSo = NULL;

  int initial_verbosity_level = 0;

  /* Arguments check. */

  if (coefficientSo == NULL)

  {

    pobyso_error_message("pobyso_parse_string",

                        "NULL_POINTER_ARGUMENT",

                        "The expression is a NULL pointer");

    return NULL;

  }

  if (! pobyso_is_constant_expression(coefficientSo))

  {

    return NULL;

  }

  if (degree < 0)

  {

    pobyso_error_message("pobyso_new_monomial",

                        "NEGATIVE_DEGREE_ARGUMENT",

                        "The degree is a negative integer");

    return NULL;

  }

  /* If degree == 0, just return a copy of the coefficient. Do not

   * return the coefficient itself to avoid "double clear" issues. */

  if (degree == 0)

  {

    initial_verbosity_level = pobyso_set_verbosity_off();

    monomialSo = sollya_lib_copy_obj(coefficientSo);

    pobyso_set_verbosity_to(initial_verbosity_level);

  }

  degreeSo    = sollya_lib_constant_from_int64(degree);

  varToPowSo  = sollya_lib_build_function_pow(sollya_lib_free_variable(),

                                              degreeSo);

  /* Do not use the "build" version to avoid "eating up" the coefficient. */

  monomialSo = sollya_lib_mul(coefficientSo,varToPowSo);

  sollya_lib_clear_obj(varToPowSo);

  /* Do not clear degreeSa: it was "eaten" by sollya-lib_build_function. */

  return monomialSo;

} /* End pobyso_new_monomial. */

/* @see pobyso.h#pobyso_parse_string*/

pobyso_func_exp_t

pobyso_parse_string(const char* expression)

{

  int expressionLength, i;

  char *expressionWithSemiCo;

  sollya_obj_t expressionSo;

  /* Arguments check. */

  if (expression == NULL)

  {

    pobyso_error_message("pobyso_parse_string",

                        "NULL_POINTER_ARGUMENT",

                        "The expression is a NULL pointer");

    return  NULL;

  }

  expressionLength = strlen(expression);

  if (expressionLength == 0)

  {

    pobyso_error_message("pobyso_parse_string",

                        "EMPTY_STRING_ARGUMENT",

                        "The expression is an empty string");

    return NULL;

  }

  /* Search from the last char of the expression until, whichever happens

   * first:

   * a ";" is found;

   * a char  != ';' is found the the ";" is appended.

   * If the head of the string is reached before any of these two events happens

   * return an error.

   */

  for (i = expressionLength - 1 ; i >= 0 ; i--)

  {

    if (expression[i] == ';') /* Nothing special to do:

                                 try to parse the string*/

    {

      expressionSo = sollya_lib_parse_string(expression);

      if (sollya_lib_obj_is_error(expressionSo))

      {

        sollya_lib_clear_obj(expressionSo);

        return NULL;

      }

      else

      {

        return expressionSo;

      }

    }

    else

    {

      if (expression[i] == ' ' || expression[i] == '\t') /* A blank,

                                                           just continue. */

      {

        continue;

      }

      else /* a character != ';' and from a blank: create the ';'ed string. */

      {

        /* Create a new string for the expression, add the ";" and

         * and call sollya_lib_parse_string. */

        expressionWithSemiCo = calloc(i + 3, sizeof(char));

        if (expressionWithSemiCo == NULL)

        {

          pobyso_error_message("pobyso_parse_string",

                                "MEMORY_ALLOCATION_ERROR",

                                "Could not allocate the expression string");

          return NULL;

        }

        strncpy(expressionWithSemiCo, expression, i+1);

        expressionWithSemiCo[i + 1] = ';';

        expressionWithSemiCo[i + 2] = '\0';

        expressionSo = sollya_lib_parse_string(expressionWithSemiCo);

        free(expressionWithSemiCo);

        if (sollya_lib_obj_is_error(expressionSo))

        {

          sollya_lib_clear_obj(expressionSo);

          return NULL;

        }

        else

        {

          return expressionSo;

        }

      } /* End character != ';' and from a blank. */

    /* Create a new string for the expression, add the ";" and

     * and call sollya_lib_parse_string. */

    } /* End else. */

  } /* End for. */

  /* We get here, it is because we did not find any char == anything different

   * from ' ' or '\t': the string is empty.

   */

  pobyso_error_message("pobyso_parse_string",

                       "ONLY_BLANK_ARGUMENT",

                        "The expression is only made of blanks");

  return NULL;

} /* pobyso_parse_string */

pobyso_func_exp_t

pobyso_remez_canonical_monomials_base(pobyso_func_exp_t function,

                                      long int degree,

                                      pobyso_range_t interval,

                                      pobyso_func_exp_t weight,

                                      double quality,

                                      pobyso_range_t bounds)

{

  sollya_obj_t  degreeSo = NULL;

  sollya_obj_t qualitySo = NULL;

  degreeSo = sollya_lib_constant_from_int(degree);

  qualitySo = sollya_lib_constant_from_double(quality);

  sollya_lib_clear_obj(degreeSo);

  sollya_lib_clear_obj(qualitySo);

  return NULL;

} /* End pobyso_remez_canonical_monomials_base. */

int

pobyso_set_canonical_on()

{

  pobyso_on_off_t currentCanonicalModeSo;

  pobyso_on_off_t on;

  currentCanonicalModeSo = sollya_lib_get_canonical();

  if (sollya_lib_is_on(currentCanonicalModeSo))

  {

    sollya_lib_clear_obj(currentCanonicalModeSo);

    return POBYSO_ON;

  }

  else

  {

    on = sollya_lib_on();

    sollya_lib_set_canonical(on);

    sollya_lib_clear_obj(on);

    sollya_lib_clear_obj(currentCanonicalModeSo);

    return POBYSO_OFF;

  }

} /* End pobyso_set_canonical_on. */

int

pobyso_set_verbosity_off()

{

  sollya_obj_t verbosityLevelZeroSo;

  sollya_obj_t currentVerbosityLevelSo = NULL;

  int currentVerbosityLevel = 0;

  currentVerbosityLevelSo = sollya_lib_get_verbosity();

  sollya_lib_get_constant_as_int(&currentVerbosityLevel,

                                 currentVerbosityLevelSo);

  verbosityLevelZeroSo = sollya_lib_constant_from_int(0);

  sollya_lib_set_verbosity(verbosityLevelZeroSo);

  sollya_lib_clear_obj(verbosityLevelZeroSo);

  sollya_lib_clear_obj(currentVerbosityLevelSo);

  return currentVerbosityLevel;

} /* End of pobyso_set_verbosity_off. */

int

pobyso_set_verbosity_to(int newVerbosityLevel)

{

  int initialVerbosityLevel = 0;

  sollya_obj_t initialVerbosityLevelSo = NULL;

  sollya_obj_t newVerbosityLevelSo = NULL;

  initialVerbosityLevelSo = sollya_lib_get_verbosity();

  sollya_lib_get_constant_as_int(&initialVerbosityLevel,

                                 initialVerbosityLevelSo);

  sollya_lib_clear_obj(initialVerbosityLevelSo);

  if (newVerbosityLevel < 0)

  {

    pobyso_error_message("pobyso_set_verbosity_to",

                        "INVALID_VALUE",

                        "The new verbosity level is a negative number");

    return initialVerbosityLevel;

  }

  newVerbosityLevelSo = sollya_lib_constant_from_int(newVerbosityLevel);

  sollya_lib_set_verbosity(newVerbosityLevelSo);

  sollya_lib_clear_obj(newVerbosityLevelSo);

  return initialVerbosityLevel;

} /* End of pobyso_set_verbosity_to. */

/**

 * @see pobyso.h#pobyso_subpoly

 */

pobyso_func_exp_t

pobyso_subpoly(pobyso_func_exp_t polynomialSo, long expsNum, long int* expsList)

{

  sollya_obj_t  expsListSo    = NULL;

  sollya_obj_t* expsList_pso  = NULL;

  sollya_obj_t subpoly        = NULL;

  int i, j;

  /* Arguments check. */

  if (polynomialSo == NULL) return NULL;

  if (expsNum < 0) return NULL;

  if (expsNum == 0) return sollya_lib_copy_obj(polynomialSo);

  if (expsList == 0) return NULL;

  /* Create a list of Sollya constants. */

  expsList_pso = (sollya_obj_t*) malloc(expsNum * sizeof(sollya_obj_t));

  if (expsList_pso == NULL)

  {

    pobyso_error_message("pobyso_subpoly",

                          "MEMORY_ALLOCATION_ERROR",

                          "Could not allocate the Sollya exponents list");

    return NULL;

  }

  /* Fill up the list. */

  for (i = 0 ; i < expsNum ; i++)

  {

    /* Abort if an exponent is negative. */

    if (expsList[i] < 0 )

    {

      for (j = 0 ; j < i ; j++)

      {

        sollya_lib_clear_obj(expsList_pso[j]);

      }

      free(expsList_pso);

      return NULL;

    }

    expsList_pso[i] = sollya_lib_constant_from_int64(expsList[i]);

  } /* End for */

  expsListSo = sollya_lib_list(expsList_pso, expsNum);

  for (i = 0 ; i < expsNum ; i++)

  {

    sollya_lib_clear_obj(expsList_pso[i]);

  }

  free(expsList_pso);

  if (expsListSo == NULL)

  {

    pobyso_error_message("pobyso_subpoly",

                          "LIST_CREATIONERROR",

                          "Could not create the exponents list");

    return NULL;

  }

  subpoly = sollya_lib_subpoly(polynomialSo, expsListSo);

  pobyso_autoprint(expsListSo);

  sollya_lib_clear_obj(expsListSo);

  return subpoly;

} /* pobyso_subpoly. */

/* Attic from the sollya_lib < 4. */

#if 0

chain*

pobyso_create_canonical_monomials_base(const unsigned int degree)

{

  int i    = 0;

  chain *monomials  = NULL;

  node  *monomial   = NULL;

  for(i = degree ; i >= 0  ; i--)

  {

     monomial   = makePow(makeVariable(), makeConstantDouble((double)i));

     monomials  = addElement(monomials, monomial);

     fprintf(stderr, "pobyso_create_canonical_monomials_base: %u\n", i);

  }

  if (monomials == NULL)