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_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();

  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();

  test = sollya_lib_get_constant(dummy, obj_to_test);

  mpfr_clear(dummy);

  pobyso_set_verbosity_to(initial_verbosity_level);

  return test;

} /* End pobyso_is_constant_expression. */

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

int

pobyso_is_free_var_posze_int_power(sollya_obj_t objToTestSo)

{

  int arity;

  sollya_base_function_t headTypeSo;

  sollya_obj_t sub1So           = NULL;

  sollya_obj_t sub2So           = NULL;

  /* Argument check. */

  if (objToTestSo == NULL)

  {

    pobyso_error_message("pobyso_is_free_var_int_poson_power",

                        "NULL_POINTER_ARGUMENT",

                        "The expression is a NULL pointer");

    return 0;

  }

  if (! sollya_lib_obj_is_function(objToTestSo))

  {

    return 0;

  }

  if (!sollya_lib_get_head_function(&headTypeSo, objToTestSo)) return 0;

  if (! sollya_lib_get_subfunctions(objToTestSo,

                                    &arity,

                                    &sub1So,

                                    &sub2So,

                                    NULL)) return 0;

  /* Power function: arity == 2. */

  if (arity != 2) return 0;

  if (! pobyso_is_constant_expression(sub1So)) return 0;

  return 1;

} /* End pobyso_is_free_var_posze_int_power. */

/** @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

  {

    pobyso_autoprint(exprSo);

    pobyso_autoprint(newConstantSo);

    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)

{

  return 0;

} /* End pobyso_is_monomial. */

/** @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)

  {

    pobyso_error_message("pobyso_create_canonical_monomial_base",

                        "CHAIN_CREATION_ERROR",

                        "Could not create the monomials chain");

    return(NULL);

  }

  return(monomials);

} /* End pobyso_create_canonical_monomials_base. */

chain*

pobyso_create_chain_from_int_array(int* intArray,

                                    const unsigned int arrayLength)

{

  int i = 0;

  chain *newChain = NULL;

  int *currentInt;

  if (arrayLength == 0) return(NULL);

  if (intArray == NULL)

  {

    pobyso_error_message("pobyso_create_chain_from_int_array",

                        "NULL_POINTER_ARGUMENT",

                        "The array is a NULL pointer");

    return(NULL);

  }

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

  {

    currentInt = malloc(sizeof(int));

    if (currentInt == NULL)

    {

      pobyso_error_message("pobyso_create_chain_from_int_array",

                          "MEMORY_ALLOCATION_ERROR",

                          "Could not allocate one of the integers");

      freeChain(newChain, free);

      return(NULL);

    }

    *currentInt = intArray[i];

    newChain = addElement(newChain, currentInt);

  }

  return(newChain);

} // End pobyso_create_chain_from_int_array. */

chain*

pobyso_create_chain_from_unsigned_int_array(unsigned int* intArray,

                                        const unsigned int arrayLength)

{

  int i = 0;

  chain *newChain = NULL;

  unsigned int *currentInt;

  /* Argument checking. */

  if (arrayLength == 0) return(NULL);

  if (intArray == NULL)

  {

    pobyso_error_message("pobyso_create_chain_from_unsigned_int_array",

                        "NULL_POINTER_ARGUMENT",

                        "The array is a NULL pointer");

    return(NULL);

  }

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

  {

    currentInt = malloc(sizeof(unsigned int));

    if (currentInt == NULL)

    {

      pobyso_error_message("pobyso_create_chain_from_unsigned_int_array",

                          "MEMORY_ALLOCATION_ERROR",

                          "Could not allocate one of the integers");

      freeChain(newChain, free);

      return(NULL);

    }

    *currentInt = intArray[i];

    newChain = addElement(newChain, currentInt);

  }

  return(newChain);

} // End pobyso_create_chain_from_unsigned_int_array. */

node*

pobyso_differentiate(node *functionNode)

{

  /* Argument checking. */

  node *differentialNode;

  if (functionNode == NULL)

  {

    pobyso_error_message("pobyso_differentiate",

                        "NULL_POINTER_ARGUMENT",

                        "The function to differentiate is a NULL pointer");

    return(NULL);

  }

  differentialNode = differentiate(functionNode);

  if (differentialNode == NULL)

  {

    pobyso_error_message("pobyso_differentiate",

                        "INTERNAL ERROR",

                        "Sollya could not differentiate the function");

  }

  return(differentialNode);

} // End pobyso_differentiate

int

pobyso_dirty_infnorm(mpfr_t infNorm,

                      node *functionNode,

                      mpfr_t lowerBound,

                      mpfr_t upperBound,

                      mp_prec_t precision)

{

  int functionCallResult;

  /* Arguments checking. */

  if (functionNode == NULL)

  {

    pobyso_error_message("pobyso_dirty_infnorm",

                        "NULL_POINTER_ARGUMENT",

                        "The function to compute is a NULL pointer");

    return(1);

  }

  if (mpfr_cmp(lowerBound, upperBound) > 0)

  {

    pobyso_error_message("pobyso_dirty_infnorm",

                        "INCOHERENT_INPUT_DATA",

                        "The lower bond is greater than the upper bound");

    return(1);

  }

  /* Particular cases. */

  if (mpfr_cmp(lowerBound, upperBound) == 0)

  {

    functionCallResult = pobyso_evaluate_faithful(infNorm,

                                                  functionNode,

                                                  lowerBound,

                                                  precision);

    return(functionCallResult);

  }

  if (isConstant(functionNode))

  {

    functionCallResult = pobyso_evaluate_faithful(infNorm,

                                                  functionNode,

                                                  lowerBound,

                                                  precision);

    if (!functionCallResult)

    {

      mpfr_abs(infNorm, infNorm, MPFR_RNDN);

    }

    return(functionCallResult);

  }

  uncertifiedInfnorm(infNorm,

                      functionNode,

                      lowerBound,

                      upperBound,

                      POBYSO_DEFAULT_POINTS,

                      precision);

  return(0);

} /* End pobyso_dirty_infnorm. */

int

pobyso_evaluate_faithful(mpfr_t faithfulEvaluation,

                          node *nodeToEvaluate,

                          mpfr_t argument,

                          mpfr_prec_t precision)

{

  /* Check input arguments. */

  if (nodeToEvaluate == NULL)

  {

    pobyso_error_message("pobyso_evaluate_faithful",

                        "NULL_POINTER_ARGUMENT",

                        "nodeToEvaluate is a NULL pointer");

    return(1);

  }

  evaluateFaithful(faithfulEvaluation,

                   nodeToEvaluate,

                   argument,

                   precision);

  return(0);

} /* End pobyso_evaluate_faithfull. */

chain*

pobyso_find_zeros(node *function,

                  mpfr_t *lower_bound,

                  mpfr_t *upper_bound)

{

  mp_prec_t currentPrecision;

  mpfr_t currentDiameter;

  rangetype bounds;

  currentPrecision = getToolPrecision();

  mpfr_init2(currentDiameter, currentPrecision);

  bounds.a = lower_bound;

  bounds.b = upper_bound;

  if (bounds.a == NULL || bounds.b == NULL)

  {

    pobyso_error_message("pobyso_find_zeros",

                        "MEMORY_ALLOCATION_ERROR",

                        "Could not allocate one of the bounds");

    return(NULL);

  }

  return(findZerosFunction(function,

                            bounds,

                            currentPrecision,

                            currentDiameter));

} /* End pobyso_find_zeros. */

void

pobyso_free_chain_of_nodes(chain *theChainOfNodes)

{

  node *currentNode           = NULL;

  chain *currentChainElement  = NULL;

  chain *nextChainElement     = NULL;

  nextChainElement = theChainOfNodes;

  while(nextChainElement != NULL)

  {

    currentChainElement = nextChainElement;

    currentNode = (node*)(currentChainElement->value);

    nextChainElement = nextChainElement->next;

    free_memory(currentNode);

    free((void*)(currentChainElement));

  }

} /* End pobyso_free_chain_of_nodes. */

void

pobyso_free_range(rangetype range)

{

  mpfr_clear(*(range.a));

  mpfr_clear(*(range.b));

  free(range.a);

  free(range.b);

} /* End pobyso_free_range. */

node*

pobyso_fp_minimax_canonical_monomials_base(node *function,

                                      int degree,

                                      chain *formats,

                                      chain *points,

                                      mpfr_t lowerBound,

                                      mpfr_t upperBound,

                                      int fpFixedArg,

                                      int absRel,

                                      node *constPart,

                                      node *minimax)

{

  return(NULL);

} /* End pobyso_fp_minimax_canonical_monomials_base. */

node*

pobyso_parse_function(char *functionString,

                      char *freeVariableNameString)

{

  if (functionString == NULL || freeVariableNameString == NULL)

  {

    pobyso_error_message("pobyso_parse_function",

                        "NULL_POINTER_ARGUMENT",

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

    return(NULL);

  }

  return(parseString(functionString));

} /* End pobyso_parse_function */

node*

pobyso_remez_approx_canonical_monomials_base_for_error(node *functionNode,

                                                  unsigned int mode,

                                                  mpfr_t lowerBound,

                                                  mpfr_t upperBound,

                                                  mpfr_t eps)

{

  node *weight              = NULL;

  node *bestApproxPolyNode  = NULL;

  node *bestApproxHorner    = NULL;

  node *errorNode           = NULL;

  rangetype degreeRange;

  mpfr_t quality;

  mpfr_t currentError;

  unsigned int degree;

  /* Check the parameters. */

  if (functionNode == NULL)

  {

    pobyso_error_message("remezApproxCanonicalMonomialsBaseForError",

                        "NULL_POINTER_ARGUMENT",

                        "functionNode is a NULL pointer");

    return(NULL);

  }

  if (mpfr_cmp(lowerBound, upperBound) >= 0)

  {

    pobyso_error_message("remezApproxCanonicalMonomialsBaseForError",

                        "INCOHERENT_INPUT_DATA",

                        "the lower_bound >= upper_bound");

    return(NULL);

  }

  /* Set the weight. */

  if (mode == POBYSO_ABSOLUTE)

  {

    /* Set the weight to 1 for the ABSOLUTE_MODE. */

    weight = makeConstantDouble(1.0);

  }

  else

  {

    if (mode == POBYSO_RELATIVE)

    {

      pobyso_error_message("computeRemezApproxCanonicalMonomialsBaseForError",

                          "NOT_IMPLEMENTED",

                          "the search for relative error is not implemented yet");

      return(NULL);

    }

    else

    {

      pobyso_error_message("computeRemezApproxCanonicalMonomialsBaseForError",

                          "INCOHERENT_INPUT_DATA",

                          "the mode is node of POBYSO_ABOLUTE or POBYSO_RELATIVE");

      return(NULL);

    }

  }

  //fprintf(stderr, "\n\n\n******* I'm here! ********\n\n\n");

  degreeRange = guessDegree(functionNode,

                            weight,

                            lowerBound,

                            upperBound,

                            eps,

                            POBYSO_GUESS_DEGREE_BOUND);

  degree = mpfr_get_ui(*(degreeRange.a), MPFR_RNDN);

  //fprintf(stderr, "\n\n\n******* I'm back! ********\n\n\n");

  fprintf(stderr, "Guessed degree: ");

  mpfr_out_str(stderr, 10, 17, *(degreeRange.a), MPFR_RNDN);

  fprintf(stderr, " - as int: %u\n", degree);

  /* Reduce the degree by 1 in the foolish hope it could work. */

  if (degree > 0) degree--;

  /* Both elements of degreeRange where "inited" within guessDegree. */

  mpfr_clear(*(degreeRange.a));

  mpfr_clear(*(degreeRange.b));

  free(degreeRange.a);

  free(degreeRange.b);

  /* Mimic the default behavior of interactive Sollya. */

  mpfr_init(quality);

  mpfr_set_d(quality, 1e-5, MPFR_RNDN);

  mpfr_init2(currentError, getToolPrecision());

  mpfr_set_inf(currentError,1);

  /* Try to refine the initial guess: loop with increasing degrees until

   * we find a satisfactory one. */

  while(mpfr_cmp(currentError, eps) > 0)

  {

    /* Get rid of the previous polynomial, if any. */

    if (bestApproxPolyNode != NULL)

    {

      free_memory(bestApproxPolyNode);

    }

    fprintf(stderr, "Degree: %u\n", degree);

    fprintf(stderr, "Calling pobyso_remez_canonical_monomials_base...\n");

    /* Try to find a polynomial with the guessed degree. */

    bestApproxPolyNode = pobyso_remez_canonical_monomials_base(functionNode,

                                                            weight,

                                                            degree,

                                                            lowerBound,

                                                            upperBound,

                                                            quality);

    if (bestApproxPolyNode == NULL)

    {

      pobyso_error_message("computeRemezApproxCanonicalMonomialsBaseForError",

                          "INTERNAL_ERROR",

                          "could not compute the bestApproxPolyNode");

      mpfr_clear(currentError);

      mpfr_clear(quality);

      return(NULL);

    }

    setDisplayMode(DISPLAY_MODE_DECIMAL);